一、接口使用interface关键字且它也会被编译成.class文件但他不是类而是一种引用数据类型接口的特点不能实例化没有构造方法方法默认public abstract修饰变量默认public static final修饰没有静态代码块抽象类特点继承了抽象类的子类要么对父类的抽象方法进行重写要么自己也是抽象类抽象类也可以拥有普通方法抽象类不能创建对象抽象类也有构造方法但是是为了子类创建对象使用定义格式public interface 接口名称 {// 抽象方法// 默认方法// 静态方法// 私有方法(JDK9)}接口包含方法分类:JDK7 只能定义抽象方法JDK8 : 默认方法、 静态方法JDK9 : 私有方法 、 私有静态方法接口中定义变量(常量):接口中只能定义常量含有抽象方法抽象方法使用 abstract 关键字修饰可以省略没有方法体。该方法供子类实现使用。代码如下interface InterFaceName {public abstract void method();}含有默认方法和静态方法默认方法使用 default 修饰不可省略供子类调用或者子类重写。​ 静态方法使用 static 修饰供接口直接调用例public interface InterFaceName {public default void method() {// 执行语句}public static void method2() {// 执行语句}}含有私有方法和私有静态方法私有方法使用 private 修饰供接口中的默认方法或者静态方法调用。例public interface InterFaceName {private void method() {// 执行语句}}接口实现实现类也就是接口的子类使用implements关键字非抽象子类实现接口1.必须重写接口中所有抽象方法。2.继承了接口的默认方法即可以直接调用也可以重写。例class 类名 implements 接口名 {// 重写接口中抽象方法【必须】// 重写接口中默认方法【可选】}具体实例定义接口public interface LiveAble {// 定义抽象方法public abstract void eat();public abstract void sleep();}定义实现类public class Animal implements LiveAble {Overridepublic void eat() {System.out.println(吃东西);}Overridepublic void sleep() {System.out.println(晚上睡);}}定义测试类public class InterfaceDemo {public static void main(String[] args) {// 创建子类对象Animal a new Animal();// 调用实现后的方法a.eat();a.sleep();}}输出结果吃东西晚上睡默认方法的使用可以继承可以重写二选一但是只能通过实现类的对象来调用。1.继承默认方法代码如下定义接口public interface LiveAble {public default void fly(){System.out.println(天上飞);}}定义实现类public class Animal implements LiveAble {// 继承什么都不用写直接调用}定义测试类public class InterfaceDemo {public static void main(String[] args) {// 创建子类对象Animal a new Animal();// 调用默认方法a.fly();}}输出结果天上飞重写默认方法代码如下定义接口public interface LiveAble {public default void fly(){System.out.println(天上飞);}}定义实现类public class Animal implements LiveAble {Overridepublic void fly() {System.out.println(自由自在的飞);}}定义测试类public class InterfaceDemo {public static void main(String[] args) {// 创建子类对象Animal a new Animal();// 调用重写方法a.fly();}}输出结果自由自在的飞静态方法的使用静态与.class 文件相关只能使用接口名调用不可以通过实现类的类名或者实现类的对象调用代码如下定义接口public interface Animal {public static void run(){System.out.println(跑起来~~~);}}定义实现类public class Cat implements Animal {// 无法重写静态方法}定义测试类public class InterfaceDemo {public static void main(String[] args) {// Cat.run(); // 【错误】无法继承方法,也无法调用Animal.run(); //}}输出结果跑起来~~~私有方法的使用私有方法只有默认方法可以调用。私有静态方法默认方法和静态方法可以调用。如果一个接口中有多个默认方法并且方法中有重复的内容那么可以抽取出来封装到私有方法中供默认方法去调用。从设计的角度讲私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上可以自行测试。定义接口public interface Animal{default void func(){func1();func2();}private void func1(){System.out.println(跑起来~~~);}private void func2(){System.out.println(跑起来~~~);}}接口的多实现一个接口可以有多个实现类一个类可以有多个子类总: 一个类只能继承一个父类可以实现多个接口实现格式class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {// 重写接口中抽象方法【必须】// 重写接口中默认方法【不重名时可选】}抽象方法接口中有多个抽象方法时实现类必须重写所有抽象方法。如果抽象方法有重名的只需要重写一次。代码如下定义多个接口interface A {public abstract void showA();public abstract void show();}interface B {public abstract void showB();public abstract void show();}实现类public class C implements A,B{Overridepublic void showA() {System.out.println(showA);}Overridepublic void showB() {System.out.println(showB);}Overridepublic void show() {System.out.println(show);}}默认方法接口中有多个默认方法时实现类都可继承使用。如果默认方法有重名的必须重写一次。代码如下定义多个接口interface A {public default void methodA(){}public default void method(){}}interface B {public default void methodB(){}public default void method(){}}实现类public class C implements A,B{Overridepublic void method() {System.out.println(method);}}静态方法接口中存在同名的静态方法并不会冲突原因是只能通过各自接口名访问静态方法。优先级的问题当一个类既继承一个父类又实现若干个接口时父类中的成员方法与接口中的默认方法重名子类就近选择执行父类的成员方法。代码如下定义接口interface A {public default void methodA(){System.out.println(AAAAAAAAAAAA);}}定义父类class D {public void methodA(){System.out.println(DDDDDDDDDDDD);}}定义子类class C extends D implements A {// 未重写methodA方法}定义测试类public class Test {public static void main(String[] args) {C c new C();c.methodA();}}输出结果:DDDDDDDDDDDD注子接口重写默认方法时default关键字可以保留。子类重写默认方法时default关键字不可以保留。二、多态概念指同一种行为具有多种不同表现形式格式父类类型 变量名 new 子类对象()变量名.方法名();**父类类型指子类对象继承的父类类型或者实现的父接口类型例Fu f new Zi();f.method();当使用多态方式调用方法时首先检查父类中是否有该方法如果没有则编译错误如果有执行的是子类重写后方法。代码如下定义父类public abstract class Animal {public abstract void eat();}定义子类class Cat extends Animal {public void eat() {System.out.println(吃鱼);}}class Dog extends Animal {public void eat() {System.out.println(吃骨头);}}定义测试类public class Test {public static void main(String[] args) {// 多态形式创建对象Animal a1 new Cat();// 调用的是 Cat 的 eata1.eat();// 多态形式创建对象Animal a2 new Dog();// 调用的是 Dog 的 eata2.eat();}}优点 : 增加代码的灵活性引用类型转换多态的转型分为向上转型与向下转型两种向上转型向上转型多态本身是子类类型向父类类型向上转换的过程这个过程是默认的。当父类引用指向一个子类对象时便是向上转型。使用格式父类类型 变量名 new 子类类型();如Animal a new Cat();向下转型向下转型父类类型向子类类型向下转换的过程这个过程是强制的。一个已经向上转型的子类对象将父类引用转为子类引用可以使用强制类型转换的格式便是向下转型。使用格式子类类型 变量名 (子类类型) 父类变量名;如:Cat c (Cat) v为什么要转型当使用多态方式调用方法时首先检查父类中是否有该方法如果没有则编译错误。也就是说不能调用子类拥有而父类没有的方法。编译都错误更别说运行了。这也是多态给我们带来的一点小麻烦。所以想要调用子类特有的方法必须做向下转型。转型演示代码如下定义类/** * Author chen * Version 1.0 * Date 2024/10/17 * Description 定义类 */ public abstract class Pet { int a50; public abstract void name(); }public class Cat extends Pet{ int a10; public void name(){ System.out.println(小黑); } public void fight(){ System.out.println(小黑在打架); } }public class Dog extends Pet{ int a100; public void name(){ System.out.println(大黄); } public void sleep(){ System.out.println(大黄在睡觉); } }定义测试类/** * Author chen * Version 1.0 * Date 2024/10/17 * Description 测试类 */ public class TestPet { public static void main(String[] args) { // 向上转型 Pet petnew Cat(); pet.name();// 调用的是 Cat 的name System.out.println(pet.a);//调用的是Pet的a // 向下转型 Cat cat (Cat) pet; cat.fight();// 调用的是 Cat 的fight System.out.println(cat.a);//调用的是Cat的a } }转型的异常转型的过程中一不小心就会遇到这样的问题请看如下代码public class Test {public static void main(String[] args) {// 向上转型Pet petnew Cat();pet.name(); // 调用的是 Cat 的 name// 向下转型Dog dog (Dog)pet;dog.sleep(); // 调用的是 Dog 的 sleep() 【运行报错】}}这段代码可以通过编译但是运行时却报出了 ClassCastException 类型转换异常这是因为明明创建了Cat类型对象运行时当然不能转换成Dog对象的。这两个类型并没有任何继承关系不符合类型转换的定义。为了避免ClassCastException的发生Java提供了 instanceof 关键字给引用变量做类型的校验格式如下变量名 instanceof 数据类型如果变量属于该数据类型返回true。如果变量不属于该数据类型返回false。所以转换前我们最好先做一个判断代码如下public class Test {public static void main(String[] args) {// 向上转型Pet petnew Cat();pet.name(); // 调用的是 Cat 的 name// 向下转型if (a instanceof Cat){Cat cat (Cat) pet; cat.fight();// 调用的是 Cat 的fightSystem.out.println(cat.a);//调用的是Cat的a} else if (a instanceof Dog){Dog dog (Dog)pet;dog.sleep(); // 调用的是 Dog 的 sleep()System.out.println(dog.a);//调用的是Cat的a}}}设计模式:原则 : 开闭原则(对扩展开发、对修改进行关闭)装饰模式 在某些情况下我们需要在不修改现有对象结构的情况下动态地添加功能或责任add(){...}①、继承add(){// 扩展能力super.add();// 扩展能力}②、装饰模式③、代理设计模式角色:组件Component定义了一个抽象的接口可以是具体对象或装饰器所共有的接口。具体组件Concrete Component实现了组件接口是被装饰的原始对象。装饰器Decorator持有一个指向组件对象的引用并实现了组件的接口。它可以包含额外的功能也可以将请求传递给组件对象。具体装饰器Concrete Decorator扩展了装饰器类通过添加额外的功能来装饰具体组件。以coffee为例首先创建一个coffee的接口作为组件/** * Author JY * Version 1.0 * Date 2024/10/15 * Description 咖啡接口 */ public interface Coffee { /** * 成本 * return */ double cost(); /** * 咖啡 描述 (普通 牛奶 糖) * return */ String description(); }其次弄一个coffeeDecorator具体组件public class CoffeeDecorator implements Coffee{ /** * 持有具体对象引用 */ private Coffee simpleCoffee ; public CoffeeDecorator(Coffee simpleCoffee) { this.simpleCoffee simpleCoffee; } Override public double cost() { return simpleCoffee.cost(); } Override public String description() { return simpleCoffee.description(); } }然后写一个coffee修饰器public class SimpleCoffee implements Coffee{ Override public double cost() { return 1.0; } Override public String description() { return Simple Coffee; } }最后再写一个具体装饰器public class MilkDecorator extends CoffeeDecorator { public MilkDecorator(Coffee simpleCoffee) { super(simpleCoffee); } Override public double cost() { return super.cost() 3.0; } Override public String description() { return super.description() 、 addMilk(); } private String addMilk() { return 添加牛奶; } }public class SugarDecorator extends CoffeeDecorator { public SugarDecorator(Coffee simpleCoffee) { super(simpleCoffee); } Override public double cost() { return super.cost() 1.0; } Override public String description() { return super.description() 、 addSugar(); } private String addSugar() { return 加糖; } }接下来就可以调用测试类进行测试了public class TestCoffee { public static void main(String[] args) { // 基本咖啡 Coffee coffee new SimpleCoffee(); coffee new SugarDecorator(coffee); coffee new MilkDecorator(coffee); System.out.println(coffee.cost()); System.out.println(coffee.description()); /* Coffee coffee new MilkDecorator(new SugarDecorator(new SimpleCoffee()));*/ // 调用能力 } }