java基础之内部类[31]

java基础之内部类[31]

---

---

---

一、什么是内部类?

内部类:在jdk1.8后取消了局部内部类中使用的变量必须显示的使用final修饰,编译器会默认加上final.
java没有多继承,但是可以使用内部类实现多重继承,每个内部类都可以继承一个接口或类.

成员:成员内部类和静态内部类;
局部:方法内部类和匿名内部类;

依赖外部类对象的:成员内部类,方法内部类,匿名内部类;
静态内部类不依赖对象,所以优先考虑(不会产生内存泄漏)

1.成员内部类:直接在类中定义的类.
在外部类创建成员内部类的实例,要用外部.内部 名称=外部对象.new 内部();因为内部类需要外部类的对象.

2.方法内部类:方法内部类只能定义在该内部类的方法内实例化,不可以在此方法外对其实例化.方法内部类对象不能使用该内部类所在方法的非final局部变量.
从内部类引用的本地变量必须是最终变量或实际上的最终变量.

二、代码演示

1.成员内部类

class InOut{
     private String name;
     public void setName(String name) {
         this.name = name;
     }
     public String getName() {
         return name;
     }
     //成员内部类,一般不建议
     class InIne{
         public void print(){
             System.out.println("成员内部类"+name);
         }
     }
     //私有化成员内部类
     private class InIne2{
         public void print2(){
             System.out.println("私有成员内部类"+name);
         }
     }
     //建议在外部类中定义一个可以访问私有内部类的方法,对外提供接口
     public void prprint(){
         InIne2 i2=new InIne2();
         i2.print2();
     }

     //方法内部类
     public void show(){

         final int a=10;
         class InIne3{
             public void In3(){
                 System.out.println("方法内部类"+name+"...."+a);
             }
         }
         InIne3 i3=new InIne3();
         i3.In3();
     }

 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2.静态内部类

静态内部类:在类中定义一个静态修饰的内部类;
静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问.
静态嵌套类只能访问外部类的静态成员和方法.

class stClass{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //静态内部类:无法在类中引用非静态变量
    static class st{
        public void print1(){
            System.out.println("静态内部类");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.匿名内部类

匿名内部类:没有名字的类.类名 对象名=new 类名(){实现方法};
1.继承式匿名内部类:在方法中实例化抽象类,并实现其方法,再在方法中调用

//抽象类
abstract class Dog{
 public abstract void eat();
}
class stClass{
	private String name;
	 //继承式匿名内部类
	 public void print2(){
	     //继承式匿名内部类
	     Dog dog=new Dog() {
	         @Override
	         public void eat() {
	             System.out.println("继承式匿名内部类"+name);
	         }
	     };
	     dog.eat();
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.接口式匿名内部类

接口式匿名内部类:在方法中实例化接口,并实现接口的方法,再在方法中调用

class stClass{
     private String name;
     //接口式匿名内部类
     public void print2(){
         //接口式匿名内部类
         Run r=new Run(){
             @Override
             public void run(){
                 System.out.println("接口式匿名内部类"+name);
             }
         };
         r.run();
 }
//接口
interface Run{
   void run();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.参数式匿名内部类

//抽象类
 abstract class Dog{
     public abstract void eat();
 }
class stClass{
 private String name;
   //参数式匿名内部类,将抽象类当做参数传进来,调用其方法
   public void print2(Dog d){
       d.eat();
   };
 }
  //参数式匿名内部类的实现
s.print2(new Dog(){
    @Override
    public void eat(){
        System.out.println("参数式匿名内部类");
    }
});
      
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

三.使用匿名内部类的注意事项

1.不能有任何构造方法,只能有一个实例;
2.不能定义任何静态成员和方法;
3.不能是public,protected,private,static.
4.一定是在new后面,用其隐含实现一个接口或者一个类;
5.匿名内部类是局部的,所以局部内部类的所有限制都生效.

---

四.小结

本章概述了java中的内部类的定义以及使用,本章内容比较多,慢慢消化,内部类中有很多不同类型的内部类,可在开发中按照高性能选择性的使用.
有哪里不足或者有更好的建议,欢迎留言吐槽,有哪里不懂的小伙伴,可以私信我,我会一一答复,感谢认可,感谢支持!