目录
1（接口）
1.1（快速入门）
UsbInterface接口类
public interface UsbInterface { //接口
//规定接口的相关方法，即规范...
public void start();
public void stop();
}
Phone手机类
//Phone 类 实现 UsbInterface
//解读1. 即 Phone类需实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止工作");
}
}Camera相机类
public class Camera implements UsbInterface{//实现接口
@Override
public void start() {
System.out.println("相机开始工作");
}
@Override
public 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{
@Override
public void hi() {
}
@Override
public 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);
}
@Override
public void swimming() {
System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
}
@Override
public 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("手机可以打电话...");
}
@Override
public void work() {
System.out.println("手机工作中...");
}
}
class Camera_ implements Usb {
@Override
public 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 {
@Override
public 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() {
@Override
public 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 {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
*/
//7. jdk底层在创建匿名内部类 Outer04$1, 立即马上就创建了 Outer04$1实例，
// 并且把地址返回给 tiger
//匿名内部类
IA tiger = new IA() {
@Override
public 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{
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
}
*/
Father father = new Father("jack"){
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2
father.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;
@Override
public 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() {
@Override
public 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 {
@Override
public 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() {
@Override
public void ring() {
System.out.println("懒猪起床了");
}
});
cellPhone.alarmClock(new Bell() {
@Override
public 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);
}
}
