B站 韩顺平 笔记 （Day 18）

目录

1（接口）

1.1（快速入门）

UsbInterface接口类

Phone手机类

Camera相机类

Computer计算机类

Interface01测试运行类

1.2（基本介绍）

1.3（注意事项与细节）

1.3.1（细节1）

1.3.2（细节2）

1.4（练习题）

1.5（接口vs继承）

1.6（接口的多态性）

详解1）：

详解2）：

1.7（练习题）

2（内部类）

2.1（简单介绍）

2.2（内部类的四种分类）

3（局部内部类）

4（匿名内部类细节）

4.1（细节1）

//演示基于接口的匿名内部类的使用，快速入门

//匿名内部类 底层系统分配类名

//演示基于类的匿名内部类

4.2（细节2）

4.3（匿名内部类实践）

4.3.1（实践1）

4.3.2（实践2）

5（成员内部类）

1（接口）

1.1（快速入门）

UsbInterface接口类

public interface UsbInterface { //接口//规定接口的相关方法，即规范...public void start();public void stop();
}

Phone手机类

//Phone 类 实现 UsbInterface
//解读1. 即 Phone类需实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{@Overridepublic void start() {System.out.println("手机开始工作");}@Overridepublic void stop() {System.out.println("手机停止工作");}
}

Camera相机类

public class Camera implements UsbInterface{//实现接口@Overridepublic void start() {System.out.println("相机开始工作");}@Overridepublic void stop() {System.out.println("相机停止工作");}
}

Computer计算机类

public class Computer {//编写一个方法，计算机工作public void work(UsbInterface usbInterface) {//通过接口来调用方法usbInterface.start();usbInterface.stop();}
}

Interface01测试运行类

public class Interface01 {public static void main(String[] args) {//创建手机，相机对象Camera camera = new Camera();Phone phone = new Phone();//创建计算机Computer computer = new Computer();computer.work(phone);//把手机接入计算机System.out.println("===================");computer.work(camera);//把相机接入计算机}
}

1.2（基本介绍）

实例：在接口中可以写属性和方法（抽象方法、默认实现方法、静态方法）

public interface AInterface {//可以写属性public int n1 = 10;//可以写方法//在接口中，抽象方法可以省略abstract关键字public void hi();//在jdk7的时候，接口里的方法全是抽象方法//在jdk8过后，可以有默认实现的方法，需要有default关键字修饰default public void ok() {System.out.println("ok...");}//在jdk8过后，可以有静态方法public static void cry() {System.out.println("cry...");}
}

1.3（注意事项与细节）

1.3.1（细节1）

Ctrl + i  快捷键可以直接把所以方法实现

1.3.2（细节2）

详解5）：

public class InterfaceDetail02 {public static void main(String[] args) {}
}
interface IB {void hi();
}
interface IC {void say();
}//一个类同时可以实现多个接口，就直接加逗号
class Pig implements IB,IC{@Overridepublic void hi() {}@Overridepublic void say() {}
}

1.4（练习题）

class B implement A因为A中没有方法，所以对

b是一个对象实例，所以可以访问public的a

B实现了A所以当然可以使用接口中的属性a

1.5（接口vs继承）

ps：实现代码解耦实际上依赖于  代码规范性  和  动态绑定机制

public class ExtendsVsInterface {public static void main(String[] args) {LittleMonkey wuKong = new LittleMonkey("悟空");wuKong.climbing();wuKong.swimming();wuKong.flying();}
}//猴子
class Monkey {private String name;public Monkey(String name) {this.name = name;}public void climbing() {System.out.println(name + " 会爬树...");}public String getName() {return name;}
}//接口
interface Fishable {void swimming();
}
interface Birdable {void flying();
}//继承
//小结:  当子类继承了父类，就自动的拥有父类的功能
//      如果子类需要扩展功能，可以通过实现接口的方式扩展.
//      可以理解 实现接口 是 对java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {public LittleMonkey(String name) {super(name);}@Overridepublic void swimming() {System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");}@Overridepublic void flying() {System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");}
}

1.6（接口的多态性）

详解1）：

public class InterfacePolyParameter {public static void main(String[] args) {//接口的多态体现//接口类型的变量 if01 可以指向 实现了IF接口类的对象实例IF if01 = new Monster();if01 = new Car();//继承体现的多态//父类类型的变量 a 可以指向 继承AAA的子类的对象实例AAA a = new BBB();a = new CCC();}
}interface IF {}
class Monster implements IF{}
class Car implements  IF{}class AAA {}
class BBB extends AAA {}
class CCC extends AAA {}

详解2）：

public class InterfacePolyArr {public static void main(String[] args) {//多态数组 -> 接口类型数组Usb[] usbs = new Usb[2];usbs[0] = new Phone_();usbs[1] = new Camera_();/*给Usb数组中，存放 Phone 和 相机对象，Phone类还有一个特有的方法call（），请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，还需要调用Phone 特有方法 call*/for(int i = 0; i < usbs.length; i++) {usbs[i].work();//动态绑定..//和前面一样，我们仍然需要进行类型的向下转型if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_((Phone_) usbs[i]).call();}}}
}interface Usb{void work();
}
class Phone_ implements Usb {public void call() {System.out.println("手机可以打电话...");}@Overridepublic void work() {System.out.println("手机工作中...");}
}class Camera_ implements Usb {@Overridepublic void work() {System.out.println("相机工作中...");}
}

instanceof 判断 运行类型

详解3）：

/*** 演示多态传递现象*/
public class InterfacePolyPass {public static void main(String[] args) {//接口类型的变量可以指向，实现了该接口的类的对象实例IG ig = new Teacher();//如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口//那么，实际上就相当于 Teacher 类也实现了 IH接口.//这就是所谓的 接口多态传递现象.IH ih = new Teacher();}
}interface IH {void hi();
}
interface IG extends IH{ }
class Teacher implements IG {@Overridepublic void hi() {}
}

1.7（练习题）

2（内部类）

2.1（简单介绍）

2.2（内部类的四种分类）

3（局部内部类）

/*** 演示局部内部类的使用*/
public class LocalInnerClass {public static void main(String[] args) {Outer02 outer02 = new Outer02();outer02.m1(); //n1=100    m2()}
}class Outer02 {//外部类private int n1 = 100;private void m2() {System.out.println("m2()");}//私有方法public void m1() {//！！！说明：局部内部类是定义在外部类的局部位置,通常在方法//！！！4.作用域: 仅仅在定义它的方法或代码块中//2.不能添加访问修饰符,但是可以使用final 修饰final class Inner02 {//局部内部类(！！！本质仍然是一个类 --> 五大成员都可以有)public void f1() {//5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()System.out.println("n1=" + n1);//1.可以直接访问外部类的所有成员(包含私有的)m2();}}//6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可Inner02 inner02 = new Inner02();inner02.f1();//        class Inner03 extends Inner02 {
//              可以这样继承
//        }}
}

解释：Outer02.this 本质就是外部类的对象, 即哪个对象调用了m1, Outer02.this就是哪个对象

4（匿名内部类细节）

4.1（细节1）

//演示基于接口的匿名内部类的使用，快速入门

public class AnonymousInnerClass {public static void main(String[] args) {Outer04 outer04 = new Outer04();outer04.method();}
}
class Outer04{//外部类private int n1 = 10;//属性public void method(){//方法//基于接口的匿名内部类//传统写法//IA tiger = new Tiger();//接口类型可以指向实现了该接口的类的对象实例//tiger.cry();//老虎叫...//匿名内部类IA tiger = new IA() {@Overridepublic void cry() {System.out.println("老虎叫...");}};tiger.cry();}
}
interface IA{//接口public void cry();
}
//class Tiger implements IA {
//    @Override
//    public void cry() {
//        System.out.println("老虎叫...");
//    }
//}

//匿名内部类 底层系统分配类名

//运行结果
//tiger的运行类型=class com.wkystu.innerclass.Outer04$1
//老虎叫...
//老虎叫...
//老虎叫...public class AnonymousInnerClass {public static void main(String[] args) {Outer04 outer04 = new Outer04();outer04.method();}
}
class Outer04{//外部类private int n1 = 10;//属性public void method(){//方法//基于接口的匿名内部类//5. tiger的编译类型 ? IA//6. tiger的运行类型 ? 就是匿名内部类  Outer04$1(系统分配的)/*我们看底层系统会分配 类名 Outer04$1，下面是底层运行时的代码class Outer04$1 implements IA {@Overridepublic void cry() {System.out.println("老虎叫唤...");}}*///7. jdk底层在创建匿名内部类 Outer04$1, 立即马上就创建了 Outer04$1实例，//   并且把地址返回给 tiger//匿名内部类IA tiger = new IA() {@Overridepublic void cry() {System.out.println("老虎叫...");}};System.out.println("tiger的运行类型=" + tiger.getClass());//getClass()是用来获取对象tiger的运行类型tiger.cry();tiger.cry();tiger.cry();//8. 匿名内部类使用一次，就不能再使用，但是tiger是个对象可以调用多次}
}
interface IA{//接口public void cry();
}

//演示基于类的匿名内部类

//运行结果：
//接收到name=jack
//father对象的运行类型=class com.wkystu.innerclass.Outer04$1
//匿名内部类重写了test方法public class AnonymousInnerClass {public static void main(String[] args) {Outer04 outer04 = new Outer04();outer04.method();}
}
class Outer04{//外部类private int n1 = 10;//属性public void method(){//方法//演示基于类的匿名内部类//分析//1. father编译类型 Father//2. father运行类型 Outer04$2//3. 底层会创建匿名内部类/*相当于底层这样运行class Outer04$2 extends Father{@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}}*/Father father = new Father("jack"){@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}};System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2father.test();//匿名内部类重写了test方法//father真正运行类型是Outer04$2，所以绑定这个test}
}
interface IA{//接口public void cry();
}class Father {//类public Father(String name) {//构造器System.out.println("接收到name=" + name);}public void test() {//方法}
}

4.2（细节2）

public class AnonymousInnerClassDetail {public static void main(String[] args) {Outer05 outer05 = new Outer05();outer05.f1();//外部其他类---不能访问----->匿名内部类System.out.println("main outer05 hashcode=" + outer05);}
}class Outer05 {private int n1 = 99;public void f1() {//创建一个基于类的匿名内部类//不能添加访问修饰符,因为它的地位就是一个局部变量//作用域 : 仅仅在定义它的方法或代码块中Person p = new Person(){private int n1 = 88;@Overridepublic void hi() {//可以直接访问外部类的所有成员，包含私有的//如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问System.out.println("匿名内部类重写了 hi方法 n1=" + n1 +" 外部内的n1=" + Outer05.this.n1 );//Outer05.this 就是调用 f1的 对象System.out.println("Outer05.this hashcode=" + Outer05.this);}};p.hi();//动态绑定, 运行类型是 Outer05$1//也可以直接调用, 匿名内部类本身也是返回对象// class 匿名内部类 extends Person {}
//        new Person(){
//            @Override
//            public void hi() {
//                System.out.println("匿名内部类重写了 hi方法,哈哈...");
//            }
//            @Override
//            public 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);}
}
//抽象类/接口...

4.3（匿名内部类实践）

4.3.1（实践1）

public class InnerClassExercise01 {public static void main(String[] args) {//匿名内部类当做实参直接传递，简洁高效f1(new IL() {@Overridepublic void show() {System.out.println("这是一副名画~~...");//这里修改比较灵活不会影响到别人}});//传统方法f1(new Picture());}//静态方法,形参是接口类型public static void f1(IL il) {il.show();}
}
//接口
interface IL {void show();
}
//类->实现IL => 编程领域 (硬编码)
class Picture implements IL {@Overridepublic void show() {System.out.println("这是一副名画XX...");//这里改变价格XX，会影响到所以有关Picture的类}
}

4.3.2（实践2）

public class InnerClassExercise02 {public static void main(String[] args) {/*1.有一个铃声接口Bell，里面有个ring方法。(右图)2.有一个手机类Cellphone，具有闹钟功能alarmClock，参数是Bell类型(右图)3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了*/CellPhone cellPhone = new CellPhone();//老韩解读//1. 传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1//2. 重写了 ring//3. Bell bell = new Bell() {//            @Override//            public void ring() {//                System.out.println("懒猪起床了");//            }//        }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接口类型System.out.println(bell.getClass());bell.ring();//动态绑定}
}

5（成员内部类）

public class MemberInnerClass01 {public static void main(String[] args) {Outer08 outer08 = new Outer08();outer08.t1();//外部其他类，使用成员内部类的三种方式//老韩解读// 第一种方式// outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员// 这就是一个语法，不要特别的纠结.Outer08.Inner08 inner08 = outer08.new Inner08();inner08.say();// 第二方式 在外部类中，编写一个方法，可以返回 Inner08对象Outer08.Inner08 inner08Instance = outer08.getInner08Instance();inner08Instance.say();}
}class Outer08 { //外部类private int n1 = 10;public String name = "张三";private void hi() {System.out.println("hi()方法...");}//1.注意: 成员内部类，是定义在外部内的成员位置上//2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员public class Inner08 {//成员内部类private double sal = 99.8;private int n1 = 66;public void say() {//可以直接访问外部类的所有成员，包含私有的//如果成员内部类的成员和外部类的成员重名，会遵守就近原则.//，可以通过  外部类名.this.属性 来访问外部类的成员System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);hi();}}//方法，返回一个Inner08实例public Inner08 getInner08Instance(){return new Inner08();}//写方法public void t1() {//使用成员内部类//创建成员内部类的对象，然后使用相关的方法Inner08 inner08 = new Inner08();inner08.say();System.out.println(inner08.sal);}
}