Java学习笔记（八）——面向对象编程（高级）

一、类变量和类方法

（一）类变量/静态变量

类变量内存布局

类变量使用注意事项和细节

（二）类方法

类方法经典的使用场景

类方法使用注意事项和细节

二、理解main方法语法

三、代码块

代码块使用注意事项和细节

四、单例设计模式

饿汉式和懒汉式的比较

五、final关键字

六、抽象类

抽象类的最佳实践——模版设计模式

七、接口

实现接口vs继承类

接口的多态特性

八、内部类

（一）局部内部类

（二）匿名内部类（重要）

匿名内部类实践

（三）成员内部类

（四）静态内部类

一、类变量和类方法

（一）类变量/静态变量

有一群小孩在玩游戏，不时有新的小孩加入，请问如何知道现在共有多少人在玩？

原有的方法：

package com.hspedu.static_;public class ChildGame {public static void main(String[] args) {int count = 0;Child child1 = new Child("小哈");Child child2 = new Child("小黑");Child child3 = new Child("小红");child1.join();count++;child2.join();count++;child3.join();count++;System.out.println(count);}
}
class Child {private String name;public Child(String name) {this.name = name;}public void join() {System.out.println(name + "加入了游戏...");}
}

存在问题：count是一个独立于对象/类的变量，以后访问count很麻烦，没有使用到OOP，因此引出类变量/静态变量。

改进：

package com.hspedu.static_;public class ChildGame {public static void main(String[] args) {Child child1 = new Child("小哈");Child child2 = new Child("小黑");Child child3 = new Child("小红");child1.join();child1.count++;child2.join();child2.count++;child3.join();child3.count++;//类变量可以通过类名访问System.out.println(Child.count); //3System.out.println(child1.count); //3System.out.println(child2.count); //3System.out.println(child3.count); //3}
}
class Child {private String name;// 定义一个变量count,是一个类变量/静态变量// 该变量最大的特点就是会被Child类的所有对象实例共享public static int count = 0;public Child(String name) {this.name = name;}public void join() {System.out.println(name + "加入了游戏...");}
}

类变量内存布局

1、类变量：也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值。同样任何一个该类的对象去修改它时，修改的也是同一个变量。

2、定义类变量：

访问修饰符 static 数据类型变量名; （推荐）

static 访问修饰符数据类型变量名;

3、访问类变量：

类名.类变量名（推荐）

对象名.类变量名

静态变量的访问修饰符的访问权限和范围和普通属性是一样的

类变量使用注意事项和细节

1、什么时候需要用类变量：当需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）。比如：定义学生类，统计所有学生共交多少钱。

2、类变量与实例变量（普通属性）的区别：类变量是该类所有对象共享的，而实例变量是每个变量独享的。

3、加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量/普通属性/普通成员变量/非静态成员变量。

4、类变量可以通过类名.类变量名或者对象名.类变量名来访问，但java设计者推荐使用类名.类变量名方式访问（前提是满足访问修饰符的访问权限和范围）。

5、实例变量不能通过类名.类变量名方式访问。

6、类变量是在类加载时就初始化了，也就是说，即使没有创建对象，只有类加载了，就可以使用类变量了。

7、类变量的生命周期是随类的加载开始，随着类消亡而销毁。

（二）类方法

类方法也叫静态方法。

基本语法：

访问修饰符 static 数据返回类型方法名(){ } （推荐）

static 访问修饰符数据返回类型方法名(){ }

类方法的调用：

类名.方法名

对象名.方法名

前提是满足访问修饰符的访问权限和范围

package com.hspedu.static_;public class StaticMethod {public static void main(String[] args) {Student tom = new Student("tom");tom.payFee(100);Student mary = new Student("mary");mary.payFee(200);Student.showFee(); //总学费有:300.0}
}
class Student {private String name;// 定义一个静态变量，来累积学生的学费private static double fee = 0;public Student(String name) {this.name = name;}// 1、当方法使用了static修饰后，该方法就是静态方法// 2、静态方法就可以访问静态属性/变量public static void payFee(double fee) {Student.fee += fee;}public static void showFee() {System.out.println("总学费有:" + Student.fee);}
}

类方法经典的使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率。比如：工具类中的方法utils Math类、Arrays类、Collections集合类。

在程序员实际开发，往往会将一些通用的方法，设计成静态方法，这样不需要创建对象就可以使用了，比如打印一维数组，冒泡排序，完成某个计算任务等...

类方法使用注意事项和细节

1、类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：

类方法中无this的参数

普通方法中隐含着this的参数

2、类方法可以通过类名调用，也可以通过对象名调用

3、普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用

4、类方法中不允许使用和对象有关的关键字，比如this和super；普通方法（成员方法）可以

5、类方法（静态方法）只能访问静态变量或静态方法

6、普通成员方法，既可以访问普通变量（方法），也可以访问静态变量（方法）

二、理解main方法语法

public static void main(String[] args){ }

1、main方法是虚拟机调用

2、java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public

3、java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

4、该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

5、java执行的程序参数1 参数2 参数3

如果希望idea里也能传参：

在main()方法中，可以直接调用main方法所在类的静态方法或静态属性。但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

三、代码块

代码块又称为初始化块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法：

修饰符 {

代码

};

1、修饰符可选，要写的话，也只能写static

2、代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的叫普通代码块/非静态代码块

3、逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）

4、;可以写上，也可以省略

代码块的好处：

1、相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作

2、如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

package com.hspedu.codeblock_;public class CodeBlock01 {public static void main(String[] args) {Movie movie1 = new Movie("你好1");System.out.println("===============");Movie movie2 = new Movie("你好2",100,"小哈");}
}
class Movie {private String name;private double price;private String director;//这样不管调用哪个构造器创建对象，都会先调用代码块的内容//代码块的优先级高于构造器{System.out.println("电影屏幕打开...");System.out.println("广告开始...");System.out.println("电影正式开始...");};// 3个构造器->重载public Movie(String name) {System.out.println("Movie(String name)被调用");this.name = name;}public Movie(String name, double price) {System.out.println("Movie(String name, double price)被调用");this.name = name;this.price = price;}public Movie(String name, double price, String director) {System.out.println("Movie(String name, double price, String director)被调用");this.name = name;this.price = price;this.director = director;}
}

代码块使用注意事项和细节

1、static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次；如果是普通代码块，每创建一个对象（new），就执行。

2、类什么时候被加载（重要）

①创建对象实例时（new）

②创建子类对象实例时，父类也会被加载

③使用类的静态成员时（静态属性，静态方法）

举例：

①创建对象实例时（new）

②创建子类对象实例时，父类也会被加载

③使用类的静态成员时（静态属性，静态方法）

3、普通的代码块，在创建对象实例（new）时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行。

4、创建一个对象时，在一个类调用顺序是（重点、难点）：

①调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按定义的顺序调用）

②调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个静态代码块和多个普通变量初始化，则按定义的顺序调用）

③调用构造方法

5、构造方法（构造器）的最前面其实隐含了super()和调用普通代码块。静态相关的代码块，属性初始化，在类加载时就执行完毕。

6、创建一个子类对象时（继承关系），他们的静态代码块、静态属性初始化、普通代码块、普通属性初始化、构造方法的调用顺序如下：

①父类的静态代码块和静态属性（优先级一样，按定义的顺序执行）

②子类的静态代码块和静态属性（优先级一样，按定义的顺序执行）

③父类的普通代码块和普通属性初始化（优先级一样，按定义的顺序执行）

④父类的构造方法

⑤子类的普通代码块和普通属性初始化（优先级一样，按定义的顺序执行）

⑥子类的构造方法

7、静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。

四、单例设计模式

什么是设计模式？（静态方法和属性的经典使用）

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，用不同的棋谱，免去自己再思考和摸索。

什么是单例设计模式？单例（单个的实例）

1、所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

2、单例设计模式有两种方式：（1）饿汉式（2）懒汉式

单例模式应用实例：

（1）构造器私有化（防止直接new）

（2）类的内部创建对象

（3）向外暴露一个静态的公共方法（getInstance）

（1）饿汉式单例模式

饿汉式可能造成创建了对象但是没有使用，造成资源浪费

package com.hspedu.single_;public class SingleTon01 {public static void main(String[] args) {System.out.println(GirlFriend.n);GirlFriend instance1 = GirlFriend.getInstance();System.out.println(instance1);GirlFriend instance2 = GirlFriend.getInstance();System.out.println(instance2);System.out.println(instance1 == instance2);}
}class GirlFriend {private String name;public static int n = 1012;//在类的内部直接创建（为了能够在静态方法中返回gf对象，需要将其修饰为static）private static GirlFriend gf = new GirlFriend("小红");// 如何保证只能创建一个对象？//饿汉式单例模式// 1、将构造器私有化private GirlFriend(String name) {System.out.println("构造器被调用...");this.name = name;}// 3、提供一个公共的static方法public static GirlFriend getInstance() {return gf;}@Overridepublic String toString() {return "GirlFriend{" +"name='" + name + '\'' +'}';}
}

（2）懒汉式单例模式

懒汉式只用当使用getInstance时才返回对象

package com.hspedu.single_;public class SingleTon02 {public static void main(String[] args) {System.out.println(boyFriend.n);boyFriend instance1 = boyFriend.getInstance();System.out.println(instance1);boyFriend instance2 = boyFriend.getInstance();System.out.println(instance2);System.out.println(instance1 == instance2);}
}class boyFriend {private String name;public static int n = 1012;//2、定义一个static静态属性对象private static boyFriend bf;//1、构造器初始化private boyFriend(String name) {System.out.println("构造器被调用...");this.name = name;}//3、提供一个public的staic方法，可以返回boyFriend对象public static boyFriend getInstance() {if(bf == null) {bf = new boyFriend("小红");}return bf;}@Overridepublic String toString() {return "boyFriend{" +"name='" + name + '\'' +'}';}
}

饿汉式和懒汉式的比较

1、二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建。

2、饿汉式不存在线程安全问题，懒汉式存在线程安全问题。

3、饿汉式存在浪费资源的可能，因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。

4、在javaSE标准类中，java.lang.Runtime就是经典的单例模式。

五、final关键字

final可以修饰类、属性、方法和局部变量。

在某些情况下，程序员可能有以下需求，就会使用到final：

1、当不希望类被继承时，可以用final关键字修饰

2、当不希望父类的某个方法被子类覆盖/重写（override）时，可以用final关键字修饰

3、当不希望类的某个属性的值被修改，可以用final关键字修饰

4、当不希望某个局部变量被修改，可以用final关键字修饰

final注意事项和细节：

1、final修饰的属性又叫常量，一般用xx_xx_xx来命名

2、final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一：

（1）定义时，如public final double TAX_RATE = 0.08;

（2）在构造器中

（3）在代码块中

3、如果final修饰的属性是静态的，则初始化的位置只能是

（1）定义时

（2）在静态代码块

不能在构造器中赋值

4、final类不能继承，但是可以实例化对象

5、如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承

6、一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法

7、final不等你修饰构造方法（构造器）

8、final和static往往搭配使用，效率更高，不会导致类的加载，底层编译器做了优化处理

9、包装类（Integer,Double,Float,Boolean等都是final），String也是final类。

六、抽象类

父类方法的不确定性：当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

package com.hspedu.abstract_;public class Abstract01 {
}
abstract class Animal {private String name;public Animal(String name) {this.name = name;}// 这里eat实现了，但是没有什么意义// 即父类方法不确定性问题// 考虑将该方法设计为抽象方法// 抽象方法就是没有实现的方法（没有方法体）
//    public void eat() {
//        System.out.println("这是一个动物，但是不知道吃什么..");
//    }//当一个类中存在抽象方法时，需要将该类声明为抽象类// 一般来说，抽象类会被继承，由其子类来实现抽象方法public abstract  void eat();
}

1、用abstract关键字来修饰一个类时，这个类就叫抽象类

访问修饰符 abstract 类名{

}

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法

访问修饰符 abstract 返回类型方法名(参数列表); //没有方法体

3、抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类

4、抽象类在框架和设计模式使用较多

抽象类使用的注意事项和细节：

1、抽象类不能被实例化

2、抽象类不一定要包含abstract方法。即抽象类可以没有abstract方法，可以有实现的方法

3、一旦类包含了abstract方法，则这个类必须声明为abstract

4、abstract只能修饰类和方法，不能修饰属性和其他的

5、抽象类可以有任意成员（因为抽象类本质还是类），比如：非抽象方法、构造器、静态属性等

6、抽象方法不能有主体，即不能实现

7、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

8、抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的

抽象类的最佳实践——模版设计模式

需求：

1、有多个类，完成不同的job

2、要求能够统计各自完成任务的时间

旧方法：

改进：

继续改进：

package com.hspedu.abstract_;abstract public class Template { // 抽象类-模版设计模式public abstract void job(); // 抽象方法public void calculateTime() { // 实现方法，调用job方法long start = System.currentTimeMillis();job(); // 动态绑定机制long end = System.currentTimeMillis();System.out.println("任务执行时间" + (end - start));}
}

package com.hspedu.abstract_;public class AA extends Template {public void job() { // 实现了Template的抽象方法joblong num = 0;for (int i = 1; i <= 8000000; i++) {num += i;}}
}

package com.hspedu.abstract_;public class BB extends Template {public void job() { // 实现了Template的抽象方法joblong num = 1;for (int i = 1; i <= 8000000; i++) {num *= i;}}
}

七、接口

接口就是给出一些没有实现的方法，到某个类要使用的时候，再根据具体情况把这些方法写出来。

interface 接口名 {

// 属性

// 方法

}

class 类名 implements 接口 {

自己属性;

自己方法;

必须实现的接口的抽象方法;

}

1、在jdk7.0前，接口里的所有方法都没有方法体，即都是抽象方法（在接口中，抽象方法可以省略abstract关键字）。

2、jdk8.0后接口类可以有静态方法，默认方法（需要使用default关键字修饰）。也就是说接口中可以有方法的具体实现。

接口的应用场景：

接口的注意事项和细节：

1、接口不能被实例化

2、接口中所有的方法是public方法，接口中的抽象方法，可以不用abstract修饰

3、一个普通类实现接口，就必须将该接口的所有方法都实现

4、抽象类实现接口，可以不用实现接口的方法

5、一个类同时可以实现多个接口

6、接口中的属性只能是final的，而且是public static final修饰符。比如：int a=1;实际上是public static final int a=1;

7、接口中属性的访问形式：接口名.属性名

8、一个接口不能继承其他的类，但是可以继承多个别的接口

9、接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

实现接口vs继承类

实现接口是对java单继承机制的补充：当子类继承了父类，就自动拥有了父类的功能；如果子类需要拓展功能，可以通过实现接口的方式扩展。

1、接口和继承解决的问题不同：继承的价值主要在于解决代码的复用性和可维护性；接口的价值主要在于设计好各种规范（方法），让其他类去实现这些方法。

2、接口比继承更加灵活：继承是满足is-a的关系，而接口只需满足like-a的关系

3、接口在一定程度上实现代码解耦（即接口规范性+动态绑定）

接口的多态特性

1、多态参数

在前面的usb接口案例，既可以接收手机对象，又可以接收相机对象，就体现了接口多态

2、多态数组

3、接口存在多态传递现象

八、内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是我们类的第五大成员，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

class Outer { // 外部类

class Inner { //内部类

}

class Other { //外部其他类

}

package com.hspedu.innerclass;public class InnerClass01 { //外部其他类public static void main(String[] args) {}
}
class Outer { //外部类private int n1 = 100; //属性public Outer(int n1) { //构造器this.n1 = n1;}public void m1() { //方法System.out.println("m1()");}{//代码块System.out.println("代码块");}class Inner { //内部类}
}

内部类的分类：

1、定义在外部类局部位置上（比如方法内）：

（1）局部内部类（有类名）

（2）匿名内部类（没有类名，重点）

2、定义在外部类的成员位置上：

（1）成员内部类（没用static修饰）

（2）静态内部类（使用static修饰）

（一）局部内部类

局部内部类是定义在外部类的局部位置，比如方法或代码块中，并且有类名。

1、可以直接访问外部类的所有成员，包括私有的

2、不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final。

3、作用域：仅仅在定义它的方法或代码块中。

4、局部内部类—访问—外部类的成员（访问方式：直接访问）

5、外部类—访问—局部内部类的成员（访问方式：创建对象，再访问注意：必须在作用域内）

6、外部其他类—不能访问—局部内部类（因为局部内部类地位是一个局部变量）

7、如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.this.成员去访问

package com.hspedu.innerclass;public class LocalInnerClass {public static void main(String[] args) {Outer02 outer02 = new Outer02();outer02.m1();//6.外部其他类—不能访问—局部内部类}
}
class Outer02 { // 外部类private int n1 = 100;private void m2() {System.out.println("Outer02 m2()");}public void m1() { // 方法// 1.局部内部类是定义在外部类的局部位置，通常在方法// 3.不能添加访问修饰符，但是可以用final修饰// 4.作用域：仅仅在定义它的方法或代码块中final class Inner02 { // 局部内部类（本质仍然是一个类）private int n1 = 800;public void f1() {// 2.可以直接访问外部类的所有成员，包含私有的//5.局部内部类可以直接访问外部类的成员//7.如果想访问外部类的成员，则可以使用 外部类名.this.成员去访问System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);m2();}}
//        class Inner03 extends Inner02 {
//        }Inner02 inner02 = new Inner02();inner02.f1();}{ // 代码块class Inner04 {}}// 6.外部类在方法中，可以创建Inner02对象，然后调用方法即可
}

（二）匿名内部类（重要）

匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

new 类或接口(参数列表) {

类体

};

注意点：（1）本质是类（2）内部类（3）该类没有名字（4）同时还是一个对象

package com.hspedu.innerclass;import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;public class AnonymousInnerClass {public static void main(String[] args) {Outer03 outer03 = new Outer03();outer03.method();}
}
class Outer03 {private int n1 = 10;public void method() {// 1、基于接口的匿名内部类// 类需要实现接口，但如果这个类只使用一次，可以使用匿名内部类来简化// implement_IA的编译类型：IA// implement_IA的运行类型：匿名内部类  Outer03$1/*底层：分配类名class Outer03$1 implements IA {@Overridepublic void cry() {System.out.println("哈哈哈");}}*/// jdk底层在创建匿名内部类Outer03$1，立马就创建了Outer03$1实例// 并且把地址返回给implement_IA// 匿名内部类使用一次就不能再使用了，但对象可以多次调用IA implement_IA = new IA() {@Overridepublic void cry() {System.out.println("哈哈哈");}};System.out.println("implement_IA的运行类型=" + implement_IA.getClass());implement_IA.cry();implement_IA.cry();implement_IA.cry();//2、基于类的匿名内部类//father的编译类型：Father//father的运行类型：Outer03$2/*底层class Outer03$2 extends Father {@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}}*/// 同时也直接返回了匿名内部类Outer03$2的对象// 注意参数列表会传递给构造器Father father = new Father("jack") {@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}};System.out.println("father对象的运行类型：" + father.getClass());father.test();//3、基于抽象类的匿名内部类Animal animal = new Animal(){@Overridevoid eat() {System.out.println("小狗吃骨头");}};}
}
interface IA {public void cry();
}
class Father {public Father(String name) {System.out.println("接收到name=" + name);}public void test() {}
}
abstract class Animal {abstract void eat();
}

匿名内部类的使用细节：

1、匿名内部类既是一个类的定义，同时它本身也是一个对象。因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类方法。

package com.hspedu.innerclass;public class AnonymousInnerClassDetail {public static void main(String[] args) {Outer04 outer04 = new Outer04();outer04.f1();}
}
class Outer04 {private int n1 = 99;public void f1() {Person p = new Person() {@Overridepublic void hi() {System.out.println("匿名内部类1重写了hi方法");}};p.hi(); //动态绑定，运行类型是Outer04$1//也可以直接调用，因为匿名内部类本身也是返回对象// class 匿名内部类 extends Person{}new Person() {@Overridepublic void hi() {System.out.println("匿名内部类2重写了hi方法");}@Overridepublic void ok(String str) {super.ok(str);}}.ok("jack");}
}
class Person {public void hi() {System.out.println("Person hi()");}public void ok(String str) {System.out.println("Person ok()" + str);}
}

2、可以访问外部类的所有成员，包含私有的

3、不能添加访问修饰符，因为它的地位就是一个局部变量

4、作用域：仅仅在定义它的方法或代码块中

5、匿名内部类—访问—外部类成员（访问方式：直接访问）

6、外部其他类—不能访问—匿名内部类（因为局部内部类地位是一个局部变量）

7、如果外部类和匿名内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.this.成员去访问

匿名内部类实践

1、当做实参直接传递，简洁高效

package com.hspedu.innerclass;import com.hspedu.abstract_.AA;public class InnerClassExercise01 {public static void main(String[] args) {// 当做实参直接传递，简洁高效f1(new IL(){@Overridepublic void show() {System.out.println("哈哈哈哈哈");}});}// 静态方法，形参是接口类型public static void f1(IL il) {il.show();}
}
interface IL {void show();
}

2、有一个铃声接口Bell，里面有个ring方法。有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型。测试手机类的闹钟功能，通过匿名内部类（对象）作为参数，打印：懒猪起床了。再传入另一个匿名内部类（对象），打印：小伙伴上课了。

package com.hspedu.innerclass;public class InnerClassExercise02 {public static void main(String[] args) {CellPhone cellPhone = new CellPhone();cellPhone.alarmclock(new Bell() {@Overridepublic void ring() {System.out.println("懒猪起床了");}});cellPhone.alarmclock(new Bell() {@Overridepublic void ring() {System.out.println("小伙伴上课了");}});}
}
interface Bell {void ring();
}
class CellPhone {public void alarmclock(Bell bell) {bell.ring();}
}

（三）成员内部类

成员内部类是定义在外部类的成员位置，并且没有static修饰

1、可以直接访问外部类的所有成员，包含私有的

2、可以添加任意访问修饰符，因为它的地位就是一个成员

3、作用域：和外部类的其他成员一样，为整个类体。比如在外部类的成员方法中创建成员内部类对象，再调用方法。

4、成员内部类 —访问—外部类（比如属性）（访问方式：直接访问）

5、外部类—访问—成员内部类（访问方式：创建对象，再访问）

6、外部其他类—访问—成员内部类（3种方式）

7、如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则。如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

package com.hspedu.innerclass;import com.sun.corba.se.impl.resolver.SplitLocalResolverImpl;public class MemberInnerClass {public static void main(String[] args) {Outer05 outer05 = new Outer05();outer05.t1();// 外部其他类访问成员内部类// 方式一：相对于把new Inner01()当做是outer05的成员Outer05.Inner01 inner01_1 = outer05.new Inner01();// 方式二：在外部类中编写一个方法，可以返回Inner01对象Outer05.Inner01 inner01_2 = outer05.getInner01Instance();inner01_2.say();// 方式三new Outer05().new Inner01();}
}
class Outer05 {private int n1 = 10;public String name = "jack";private void hi() {System.out.println("hi()...");}// 成员内部类是定义在外部类的成员位置// 可以添加任意访问修饰符public class Inner01 {private int n1 = 66;private double n2 = 99.9;public void say() {// 成员内部类访问外部类,可以直接访问外部类的所有成员，包含私有的System.out.println("n1=" + n1 + " name=" + name);System.out.println("Outer05的n1:" + Outer05.this.n1);hi();}}public void t1() {// 外部类访问成员内部类（访问方式：创建对象，再访问）Inner01 inner01 = new Inner01();inner01.say();System.out.println(inner01.n2);}// get方法，返回一个Inner01实例public Inner01 getInner01Instance() {return new Inner01();}
}

（四）静态内部类

静态内部类是定义在外部类的成员位置，并且有static修饰。

1、可以直接访问外部类的所有成员，包含私有的，但不能直接访问非静态成员

2、可以添加任意访问修饰符，因为它的地位就是一个成员

3、作用域：同其他的成员，为整个类体。

4、静态内部类 —访问—外部类（比如静态属性）（访问方式：直接访问所有静态成员）

5、外部类—访问—静态内部类（访问方式：创建对象，再访问）

6、外部其他类—访问—静态内部类

7、如果外部类和静态内部类的成员重名时，静态内部类访问的话，默认遵循就近原则。如果想访问外部类的成员，则可以使用（外部类名.成员）去访问

package com.hspedu.innerclass;public class StaticInnerClass {public static void main(String[] args) {Outer06 outer06 = new Outer06();outer06.m1();// 外部其他类访问静态内部类// 方式一：因为静态内部类是可以通过类名直接访问（前提是满足访问权限）Outer06.Inner02 inner02_1 = new Outer06.Inner02();inner02_1.say();// 方式二：编写一个方法，可以返回静态内部类的对象实例Outer06.Inner02 inner02_2 = outer06.getInner02Instance();// 方式三Outer06.Inner02 inner02_3 = Outer06.getInner02_();}
}
class Outer06 {private int n1 = 10;private static String name = "jack";private static void cry() {}// 静态内部类是定义在外部类的成员位置，并且有static修饰// 可以添加任意访问修饰符public static class Inner02 {private static String name = "tom";public void say() {// 静态内部类访问外部类：可以直接访问外部类的所有成员，包含私有的，但不能直接访问非静态成员System.out.println(name);System.out.println("Outer06的name:" + Outer06.name);cry();}}// 外部类访问静态内部类：创建对象，再访问public void m1() {Inner02 inner02 = new Inner02();}// get方法，返回一个Inner02实例public Inner02 getInner02Instance() {return new Inner02();}public static Inner02 getInner02_() {return new Inner02();}
}