Java入门基础day29

day29

内部类

分类

非静态成员内部类

静态成员内部类

局部内部类

匿名内部类

概念

在一个类的内部，再定义一个完整的类

特点：

编译之后可以生成一个独立的字节码class文件

内部类可以直接访问外部类的私有成员，而不会破坏其封装性

可以为外部类提供必要的内部功能组件

package com.saas.oo1;
​
public class Outer {
​
 private int num = 100;
​
 class Inner{
     public void test(){
         System.out.println(num);
     }
 }
}

在Inner类中可以访问Outer类里面的私有成员num

因为Inner类是Outer类的内部类

内部类可以访问外部类的私有成员

内部类的成员访问

package com.saas.oo1;
​
public class Outer03 {
​
 int num;
​
 public void test01(){
     System.out.println("this is test01 method.");
 }
​
 public class Inner01{
     double score;
​
     public void test02(){
         System.out.println("this is test02 method.");
     }
 }
}

package com.saas.oo1;
​
public class TestOutter03 {
​
 public static void main(String[] args) {
     Outer03 o = new Outer03();
​
     o.num = 1000;
     System.out.println(o.num);
     o.test01();
​
     System.out.println("================");
​
     Outer03.Inner01 i01 = new Outer03().new Inner01();
​
     i01.score = 99.99;
     System.out.println(i01.score);
     i01.test02();
 }
}

Inner01作为Outter03的内部类，其地位与非静态成员num和test01类似

想要访问num和test01就必须得创建Outter03对象

类似的也可以通过Outter03对象来访问Inner01

所以就像访问num和test01一样访问Inner类中的score和test02

package com.saas.oo1;
​
public class Outer03 {
​
 int num;
​
 static int n;
​
 public void test01(){
     System.out.println("this is test01 method.");
 }
​
 public static void test03(){
     System.out.println("this is test03 method.");
 }
​
 public class Inner01{
     double score;                //  非静态内部类中可定义非静态属性
​
     //static double score02;      //  非静态内部类中不可定义静态属性
​
     public void test02(){       //  非静态内部类中可定义非静态方法
         System.out.println("this is test02 method.");
     }
​
//        public static void test05(){          //  非静态内部类中不能定义静态方法
//
//        }
 }
​
 public static class Inner02{
     static double score;
​
     double score02;             //  静态内部类中可以定义非静态成员变量
​
     public static void test04(){
         System.out.println("this is test04 method.");
     }
​
     public void test06(){       //  静态内部类中可以定义非静态成员方法
         System.out.println("this is test06 method.");
     }
 }
}

package com.saas.oo1;
​
public class TestOutter03 {
​
 public static void main(String[] args) {
     Outer03 o = new Outer03();
​
     o.num = 1000;
     System.out.println(o.num);
     o.test01();
​
     System.out.println("================");
​
     Outer03.Inner01 i01 = new Outer03().new Inner01();
​
     i01.score = 99.99;
     System.out.println(i01.score);
     i01.test02();
​
     System.out.println("================");
​
     Outer03.n = 2000;
​
     System.out.println(Outer03.n);
     Outer03.test03();
​
     System.out.println("================");
​
     Outer03.Inner02.score = 88.88;
     System.out.println(Outer03.Inner02.score);
     Outer03.Inner02.test04();
​
     System.out.println("================");
​
     Outer03.Inner02 i02 = new Outer03.Inner02();
​
     i02.score02 = 77.77;
     System.out.println(i02.score02);
     i02.test06();
 }
}

在一个类的内部可以分别定义非静态内部类和静态内部类

非静态内部类中只能定义非静态成员变量和非静态成员方法，访问该非静态成员如下：

new Outter().new Inner().xxx，   访问非静态成员变量
new Outter().new Inner().xxx(), 访问非静态成员方法

非静态内部类中不能定义静态成员属性和静态成员方法

静态成员内部类可以定义静态成员属性和静态成员方法，访问该静态成员如下：

Outer.Inner.xxx.                访问静态成员变量
Outer.Inner.xxx().              访问静态成员方法    

静态内部类中还可以定义非静态成员属性和非静态成员方法：访问如下：

new Outer.Inner().xxx           访问非静态成员变量
new Outer.Inner().xxx()         访问非静态成员方法

局部内部类

定义在外部类的方法中，作用范围和创建对象的范围仅限于当前方法

局部内部类访问外部类当前方法中的局部变量时，因无法保证变量的生命周期与自身相同，变量必须得用final修饰，注意jdk7的区别

限制类的使用范围

package com.saas.oo1;

public class Outer05 {

 public void test(){


//        Inner in02 = new Outer.Inner();
//
//        in02.m = 999;
//        in02.test01();

     class Inner{
         int m ;

         public void test01(){
             System.out.println("this is test01");
         }
     }

     Inner in = new Inner();     //  局部内部类的作用范围是从定义位置开始到方法结束

     in.m = 12;
     System.out.println(in.m);
     in.test01();
 }

 public void test02(){
//        Inner in = new Inner();       //  局部内部类作用于某一个方法，在当前方法中可以访问，其他方法不能访问
 }

 public static void main(String[] args) {
     Outer05 o = new Outer05();

     o.test();
 }
}

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）

必须继承一个父类或者实现一个接口

定义类、实现类、创建对象的语法合并，只能创建一个类的对象

优点：减少代码量

缺点：可读性较差

package com.saas.oo2;

public interface USB {

 void service();
}

package com.saas.oo2;

public class Mouse implements USB{
 @Override
 public void service() {
     System.out.println("mouse starts working...");
 }
}

package com.saas.oo2;

public class Test {

 public static void main(String[] args) {
     Mouse m = new Mouse();

     m.service();

     System.out.println("===============");

     USB keyBoard = new USB() {
         @Override
         public void service() {
             System.out.println("键盘开始工作。");
         }
     };

     keyBoard.service();
     keyBoard.service();
     keyBoard.service();
     keyBoard.service();

     System.out.println("===============");

     new USB(){
         @Override
         public void service() {
             System.out.println("风扇开始工作");
         }
     }.service();

     System.out.println("===============");

     new USB(){
         @Override
         public void service() {
             System.out.println("小米su7汽车开始工作");
         }
     }.service();

     System.out.println("===============");

     System.out.println(new Object() {
         @Override
         public String toString() {
             return "hehe";
         }
     }.toString());
 }
}