石家庄建设银行网站,视频号视频怎么看下载链接,微信商城网站怎么做的,网站做cdn需要注意什么意思接口#xff08;interface#xff09;明确了描述类被授权了哪些能力#xff0c;但不会指定具体的方式。实现类#xff08;implement#xff09;一个或多个接口。–使类完成了实现#xff0c;是一种对于行为规范的准则的抽象。
个体的方法可以在子类中自写展现#…接口interface明确了描述类被授权了哪些能力但不会指定具体的方式。实现类implement一个或多个接口。–使类完成了实现是一种对于行为规范的准则的抽象。
个体的方法可以在子类中自写展现当多个子类均拥有相同的需求的时候就需要凭借接口来快速的高效的完成。
接口是一种规范或契约它只包含方法的声明没有方法的实现。一个类可以实现一个或多个接口并提供接口中定义的所有方法的具体实现。Java接口interface 1 明确接口中的三个关系 2 接口中的成员[ 1 ] 成员变量~~[ 2 ] 构造方法~~ --- 是不存在的[ 3 ] 成员方法【 1 】JDK7 接口只能定义抽象方法【 2 】JDK8:接口可以有定义的方法体默认静态1允许接口定义默认方法default修饰Java类和多接口的时候若多接口中存在重名的方法而优先类中没有复写用eclisp的快捷方式为什么只有靠近implement的接口中的方法解决办法解决办法 (2)允许接口中定义定义静态方法需要用static修饰 【 3 】JDK9接口有私有方法1为什么showB需创建对象而A的却不用2普通的私有方法给default默认方法服务普通的私有方法给默认方法服务的。default删去 3 对比代码[ 1 ] 没有抽象方法的抽象实现类[ 2 ] 实现类是抽象类的类 4 InterApply:代码举例[ 1 ]分析代码为什么在main方法中必须强转circle从Shape到Circle的时候setRadius才能用: 代码举例[ 2 ]分析 5 适配器模式Adapter Pattern代码1代码2 接口不同于类其在Java是一种抽象类型的体现将抽象的方法集中到一起。以关键字interface来声明一个类通过继承接口的方式关键字implement来实现我们所需的方法。 实现接口的类是抽象类否则该类要定义接口中的所有方法。1 明确接口中的三个关系
1. 类和类之间的继承关系
继承可单不可多但可多层。让子类继承父类的属性和方法继承是面向对象编程中一种重要的关系它允许一个类子类/派生类继承另一个类父类/基类的属性数据成员和方法函数成员。子类可以获得父类的属性和方法并且可以在此基础上添加新的属性和方法或者重写父类的方法。继承可以是单继承一个子类只能有一个父类或多层继承一个子类可以继承自另一个子类形成继承链。
package oop_useInterface;public abstract class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name name;this.age age;}/*此处省略getter() setter()方法*/public abstract void eat(String age);
}
Dog继承了Animal的字段并重写了eat这个抽象方法实现了具体的能力
package oop_useInterface;public class Dog extends Animal implements Swim{public Dog() {super();}public Dog(String name, int age) {super(name, age);}public void swim(int age) {System.out.println(DOg Swim);}Overridepublic void eat(String a) {System.out.println(DOG EAT);}}2. 类和接口之间的实现关系
实现关系可单多实现还可以在继承一个类的同时实现多个接口。使类必须实现接口中定义的方法接口是一种规范它定义了一组方法的签名方法名、参数类型和返回类型但没有具体的实现。类可以实现一个或多个接口这意味着类需要提供接口中定义的所有方法的具体实现。实现关系是类与接口之间的关系它强制类实现接口中定义的方法。这种关系使得类可以符合特定的接口标准从而可以更容易地交互和替换。
public interface Swim {public abstract void swim(int age);
}按照上方Dog类的implement的关键字证明Dog接入了Swim这个接口中的swim方法将其里面的抽象方法重写实现了Dog类拥有swim方法。 3. 接口和接口之间的继承关系
继承关系可单可多实现类需要重写所有的抽象方法新接口继承已有接口的方法签名接口之间也可以存在继承关系类似于类之间的继承关系。一个接口可以继承自一个或多个接口这样新的接口就会继承已有接口的方法签名。实现类需要重写所有的抽象方法。这种继承关系允许你在新接口中定义更多的方法并且同时继承了父接口中的方法签名。如果一个类实现了一个继承自其他接口的接口那么它需要提供所有继承的接口方法的具体实现。
// 定义基础接口 Shape
interface Shape {void draw();
}// 定义继承自 Shape 的 Resizable 接口
interface Resizable extends Shape {void resize(int percentage);
}// 定义继承自 Resizable 的 Drawable 接口
interface Drawable extends Resizable {void colorize(String color);
}2 接口中的成员
[ 1 ] 成员变量
接口中有常量且只能是常量。这就意味着常量在接口中只能被默认的修饰为public static final这意味着它们是全局可访问的常量。这些常量通常用于定义接口相关的常量值且不可被更改。
[ 2 ] 构造方法 — 是不存在的
接口是不存在构造方法的
[ 3 ] 成员方法
【 1 】JDK7 接口只能定义抽象方法
当接口内的规则指新增抽象方法一改增导致下面的实现类需要随之改增。
原因实现类需要重写所有的抽象方法在 JDK 8 之后的版本中Java 引入了默认方法default methods和静态方法static methods的概念允许在接口中提供方法的默认实现但这也是有限制的而且默认方法引入了一些新的问题和考虑事项。
【 2 】JDK8:接口可以有定义的方法体默认静态
接口的能力升级实现类无需立即进行修改只需遵循某些规则并进行重写即可。
1允许接口定义默认方法default修饰
格式Lpublic default 返回值类型 方法名参数列表{
实例Lpublic default void show(){}**注意事项[1]默认方法不是抽象方法不强制被重写如果被重写徐去掉default关键字[2]public可以省略default不能省略如果省略Java会将其当做抽象方法[3]如果实现多个接口多个接口存在相同名字的默认方法子类就必须对改方法进行重写Java类和多接口的时候若多接口中存在重名的方法而优先类中没有复写用eclisp的快捷方式为什么只有靠近implement的接口中的方法解决办法
如果一个类实现了多个接口而这些接口中有重名方法但类本身没有复写这个方法Eclipse通常会根据implement关键字后面的接口的顺序选择第一个接口中的方法作为默认方法。
解决办法
1手写自己想要的方式 2放在波浪线上表示有一个或多个建议的操作。- -这个仅仅是继承了接口中的default默认方法
(2)允许接口中定义定义静态方法需要用static修饰
格式L:public static 返回值类型 方法名参数列表{}
实例L:public static void show(){}**注意事项[1]静态方法只能通过接口名调用不能通过实现类名或者对象名调用[2]public可以省略static不能省略。如果省略Java会将其当做抽象方法[3]静态方法不可重写
再次理解重写子类把父类继承下来的虚方法表里面的方法覆盖的过程。静态的私有的最终的不会添加到方法表的。 Inter
package oop_useInterface5_JDK8_NewMethod2;public interface Inter {public abstract void method();public static void show() {System.out.println(Inter-static Method);}
}
InterImpl
package oop_useInterface5_JDK8_NewMethod2;public class InterImpl implements Inter{Overridepublic void method() {System.out.println(InterImpl-overideMethod);}//实现类不可被重写需要去掉Override//不叫重写只是一个重名的方法public static void show() {System.out.println(InterImpl-static Method);}
}
Test
package oop_useInterface5_JDK8_NewMethod2;public class Test {public static void main(String[] args) {
//下面只是重名的方法 //接口中静态方法Inter.show();//实现了的静态方法InterImpl.show();}//再次理解重写 子类把父类继承下来的虚方法表里面的方法覆盖的过程。//静态的私有的最终的不会添加到方法表的。
} 【 3 】JDK9接口有私有方法
JDK9以前一个接口在两个default方法如果有相同的表述可以采用在写一个default方法抽取出来如何调用对应方法但抽取是为本代码访问不想被外类使用所以要变访问修饰符 --抽离方法
[1]普通的私有方法给default默认方法服务普通的私有方法给默认方法服务的。default删去格式1Lprivate 返回值类型 方法名参数列表{}实例1Lprivate void show(){}[2]静态的使用方法给static静态方法服务静态的私有方法给静态方法服务的格式2Lprivate static 返回值类型 方法名参数列表{}实例2Lprivate static void method(){}Inter1
package oop_useInterface5_JDK9_New_PrivateMethod;public interface Inter1 {public static void showA() {System.out.println(ShowA--run);RunB();}public default void showB() {System.out.println(ShowB--run);RunA();}// public default void Run() {
// System.out.println(Running);
// }//普通的私有方法给默认方法服务的。default删去private void RunA() {System.out.println(Running);}//静态的私有方法给静态方法服务的private static void RunB () {System.out.println(Running);}
}
main方法
package oop_useInterface5_JDK9_New_PrivateMethod;public class Testsss {public static void main(String[] args) {Inter1.showA(); // 调用静态的接口方法Inter1 inter1 new Inter1Impl();inter1.showB(); // 调用默认的接口方法}
}
class Inter1Impl implements Inter1 {Overridepublic void showB() {// TODO 自动生成的方法存根Inter1.super.showB();}// 实现类不需要实现私有方法
}
1为什么showB需创建对象而A的却不用
静态方法是与接口本身关联的与实现类无关因此可以通过接口名称来直接调用。这就是为什么您可以使用 Inter1.showA() 这样的方式调用 showA 方法无需创建实现类的对象。
默认方法是为了向已有的接口添加新方法而引入的这样可以保证已有的类库仍然能够正常工作。因此默认方法在实现类中必须被实现而且需要通过实现类的对象来调用因为默认方法是实例方法与特定的实例相关联。
2普通的私有方法给default默认方法服务普通的私有方法给默认方法服务的。default删去
如果不去掉default
Illegal combination of modifiers for the private interface method RunA; additionally only one of static and strictfp is permitted 当去除default就可以为其服务 3 对比代码
[ 1 ] 没有抽象方法的抽象实现类
虽然是抽象实现类接口中的没有声明是默认的、静态的、私有的就会被认为是抽象的方法抽象的方法一定要去重写赋予具体的实现过程。
interface MyInterface {void method1(); // 接口中的方法void method2();
}class MyConcreteClass implements MyInterface {public void method1() {System.out.println(执行 method1);}public void method2() {System.out.println(执行 method2);}
}public class sadasd {public static void main(String[] args) {MyConcreteClass myObject new MyConcreteClass();myObject.method1(); // 输出执行 method1myObject.method2(); // 输出执行 method2}
}
[ 2 ] 实现类是抽象类的类
public interface MyInterface {void method1(); // 接口中的方法void method2();
}public abstract class MyAbstractClass implements MyInterface {public void method1() {System.out.println(执行 method1);}// method2没有提供具体实现
}public class MyConcreteClass extends MyAbstractClass {public void method2() {System.out.println(执行 method2);}
}public class Main {public static void main(String[] args) {MyConcreteClass myObject new MyConcreteClass();myObject.method1(); // 输出执行 method1myObject.method2(); // 输出执行 method2}
}
一定要实现其中的抽象方法 The type MyConcreteClass must implement the inherited abstract method MyInterface.method2() 4 InterApply:
public interface Method{}public void show(Method的接口 c{}即接口类型 x new 实现类对象编译看左边运行看右边接口代表规则是行为的抽象 接口是 Java 中用于定义一组方法签名即方法名称、参数列表和返回类型的规范。它们不包含方法的具体实现只声明了方法的签名。类可以实现一个或多个接口从而表明它们将遵循这些接口所定义的规则也就是行为。 方法的参数是接口时可以传递接口所有实现类的对象–接口多态 当一个方法的参数是接口类型时可以传递实现了该接口的任何类的对象作为参数。这体现了多态的概念即你可以在运行时传递不同的对象实现不同的行为但是方法的定义只关心接口所规定的方法签名。 接口和抽象类不可以实例化 创建实现了接口的类的对象或者从抽象类派生出具体的子类然后通过这些对象进行实例化。这也是多态的体现。是指不能直接通过 new 关键字实例化接口或抽象类但是可以传递引用实现多态。意思是不能直接使用new 接口名或new 抽象类名·来创建对象。 但可以通过类实现接口或继承抽象类并创建实现类的对象。这些实现类可以通过接口引用来实现多态从而在不同的上下文中使用不同的实现。 编译时和运行时 在Java 中有一个重要的原则是“编译看左边运行看右边”。这指的是在编译阶段编译器只关注左边(变量的声明类型)而在运行时实际执行的方法是根据右边(对象的实际类型)确定的。
代码举例[ 1 ]
package com.example.shapes;public interface Shape {double calculateArea();
}package com.example.shapes;public class Circle implements Shape {private double radius;public Circle(double radius) {this.radius radius;}public double getRadius() {return this.radius;}public void setRadius(double radius) {this.radius radius;}Overridepublic double calculateArea() {return Math.PI * radius * radius;}
}package com.example.shapes;public class Rectangle implements Shape {private double width;private double height;public Rectangle(double width, double height) {this.width width;this.height height;}Overridepublic double calculateArea() {return width * height;}
}package com.example.shapes;public class AreaCalculator {public void printArea(Shape shape) {double area shape.calculateArea();System.out.println(Area: area);}
}package com.example.shapes;public class Main {public static void main(String[] args) {Shape circle new Circle(5);Shape rectangle new Rectangle(4, 6);if (circle instanceof Circle) {((Circle) circle).setRadius(123);double radius ((Circle) circle).getRadius();System.out.println(Circle Radius: radius);} else {System.out.println(circle is not an instance of Circle);}AreaCalculator calculator new AreaCalculator();calculator.printArea(circle); // Output: Area: 78.53981633974483calculator.printArea(rectangle); // Output: Area: 24.0}
}分析代码 接口代表规则是行为的抽象 在代码中Shape 接口就是一个很好的示例。它定义了一个名为 calculateArea() 的方法表达了所有实现了该接口的类应该提供计算面积的行为。Circle 和 Rectangle 类实现了 Shape 接口表明它们都遵循了这一规则并提供了自己的面积计算方法。 方法的参数是接口时可以传递接口所有实现类的对象 在 AreaCalculator 类中的 printArea(Shape shape) 方法就是这个例子。它的参数是一个接口类型 Shape但你可以传递实现了 Shape 接口的任何类的对象如在 main 方法中所示。这允许你传递不同类型的图形比如 Circle 和 Rectangle作为参数但方法的定义只关心 Shape 接口的规范。 接口和抽象类不可以实例化 接口 Shape 是无法直接实例化的而 Circle 和 Rectangle 作为它的实现类可以通过 new 关键字实例化。在 main 方法中你使用了多态来创建一个 Circle 对象和一个 Rectangle 对象并将它们赋给了 Shape 类型的引用变量 circle 和 rectangle。
为什么在main方法中必须强转circle从Shape到Circle的时候setRadius才能用:
在代码中在main方法中创建了一个Shape类型的对象 circle并且将它实际实例化为了一个Circle对象。然而由于你将其声明为Shape类型编译器只知道它是一个实现了Shape接口的对象并没有直接访问Circle类中特有的方法和属性的权限。
当你尝试在circle对象上调用setRadius方法时编译器无法确定这个方法是否存在于Shape接口中因为在Shape接口中并没有定义这个方法。因此编译器会报错提示Shape接口中没有setRadius方法。
为了解决这个问题可以使用强制类型转换 (Circle) circle 将 circle 对象转换为 Circle 类型。这样编译器就知道你希望将它视为 Circle 类型可以调用 Circle 类中定义的方法和属性。
然而需要注意的是强制类型转换存在一些风险因为你需要确保对象实际上是你期望的类型。如果你尝试将一个不是 Circle 类型的对象进行强制转换会在运行时抛出 ClassCastException。
在你的代码中由于你在 main 方法中已经创建了一个 Circle 对象并将其赋给了 circle 变量因此强制类型转换是安全的但是通常最好在进行强制类型转换之前使用 instanceof 进行类型检查以避免可能的异常情况。你在代码中使用了 instanceof 来检查 circle 是否是 Circle 类型的实例然后才进行强制类型转换这是一个良好的实践。
总结一下在 main 方法中使用强制类型转换是为了获得更多关于对象的类型信息从而让编译器识别并允许访问特定类型的方法和属性。但是要注意类型转换的安全性避免出现运行时异常。
代码举例[ 2 ]
// 定义接口
public interface Animal {void makeSound();
}// 实现接口的 Dog 类
public class Dog implements Animal {Overridepublic void makeSound() {System.out.println(Dog barks);}
}// 实现接口的 Cat 类
public class Cat implements Animal {Overridepublic void makeSound() {System.out.println(Cat meows);}
}// 主类
public class Main {// 方法参数是接口类型可以接受实现了该接口的任何类的对象public void animalSound(Animal animal) {animal.makeSound();}public static void main(String[] args) {Main main new Main();Animal dog new Dog(); // 实现类对象通过接口引用Animal cat new Cat(); // 实现类对象通过接口引用main.animalSound(dog); // 编译时 Animal运行时 Dog 的 makeSoundmain.animalSound(cat); // 编译时 Animal运行时 Cat 的 makeSound}
}
分析
多态是面向对象编程的一个重要特性它允许你使用基类或接口类型的引用来引用派生类或实现类的对象从而在运行时根据对象的实际类型来决定调用哪个方法。在这个示例中Animal 是一个接口Dog 和 Cat 是实现了 Animal 接口的类。通过将 Dog 和 Cat 的实例赋值给 Animal 类型的引用你可以在 animalSound 方法中使用多态根据实际的对象类型来调用正确的 makeSound 方法。
这种方法使得代码更加灵活和可扩展因为你可以添加更多实现了 Animal 接口的类而不需要修改 animalSound 方法的代码从而实现了代码的开闭原则。 5 适配器模式Adapter Pattern
当一个接口中的抽象方法过多但只需要使用其中一部分时候采用【相当于一个方法表】步骤 编写中间类 接口名Adapter 实现对应接口对接口中的抽象方法进行空实现让真正的实现类继承中间类并重写需要的方法为了避免其他类创建适配器类的对象中间的适配器类用abstract修饰
细节继承的实现类还有多个继承可以采取间接继承【因为Java没有多继承的】代码1
下面是一个简单的示例代码来演示适配器模式的用法。在这个示例中我们使用适配器模式来适配一个已有的LegacyRectangle类旧接口到一个新的Rectangle接口新接口只需要使用Rectangle接口的一部分方法。
// 定义新的目标接口
interface Rectangle {void draw();void resize();
}// 旧的LegacyRectangle类旧接口
class LegacyRectangle {void oldDraw() {System.out.println(LegacyRectangle: Drawing);}void oldResize() {System.out.println(LegacyRectangle: Resizing);}
}// 适配器类将LegacyRectangle适配到Rectangle接口
abstract class RectangleAdapter implements Rectangle {Overridepublic void draw() {// 空实现可以在子类中选择实现}Overridepublic void resize() {// 空实现可以在子类中选择实现}
}// 实际的适配器继承RectangleAdapter并实现需要的方法
class LegacyRectangleAdapter extends RectangleAdapter {private LegacyRectangle legacyRectangle;public LegacyRectangleAdapter(LegacyRectangle legacyRectangle) {this.legacyRectangle legacyRectangle;}Overridepublic void draw() {legacyRectangle.oldDraw();}Overridepublic void resize() {legacyRectangle.oldResize();}
}public class AdapterPatternExample {public static void main(String[] args) {// 使用适配器来调用LegacyRectangle的方法看起来像是调用Rectangle接口的方法LegacyRectangle legacyRectangle new LegacyRectangle();Rectangle adapter new LegacyRectangleAdapter(legacyRectangle);adapter.draw(); // 实际调用LegacyRectangle的oldDraw方法adapter.resize(); // 实际调用LegacyRectangle的oldResize方法}
}在这个示例中LegacyRectangle是旧接口Rectangle是新接口。我们创建了一个RectangleAdapter作为适配器抽象类然后创建了一个具体的适配器类LegacyRectangleAdapter它继承自RectangleAdapter并将LegacyRectangle适配到了Rectangle接口。在main方法中我们可以看到通过适配器来调用LegacyRectangle的方法实际上调用的是旧接口的方法但通过适配器它们看起来像是在调用新接口的方法。
代码2
// 定义原始接口
interface Shape {void draw();
}// 定义更新后的接口
interface UpdatedShape {void draw();void resize();
}// 中间适配器类用 abstract 修饰提供空实现
abstract class ShapeAdapter implements UpdatedShape {Overridepublic void draw() {// 空实现}Overridepublic void resize() {// 空实现}
}// 实现类继承适配器类只需要重写需要的方法
class CircleAdapter extends ShapeAdapter {private Shape adaptedShape;public CircleAdapter(Shape shape) {this.adaptedShape shape;}Overridepublic void draw() {adaptedShape.draw();}
}// 圆形类实现原始接口
class Circle implements Shape {Overridepublic void draw() {System.out.println(Drawing a circle);}
}public class Main {public static void main(String[] args) {Shape circle new Circle();UpdatedShape updatedCircle new CircleAdapter(circle);updatedCircle.draw(); // 调用原始方法updatedCircle.resize(); // 调用新增方法空实现}
}
这个新的接口就是说是这个旧的就接口的一种接口升级。然后又因为这个接口中的抽象方法必须在实现类中进行重写使用需要一个适配器重写这个新的接口中的方法。 其中的自己适配器类是为了扩展新的方法最后到达这个继承下来的真正的适配器就完成了新的接口内部方法的复写
Shape circle new Circle(); UpdatedShape updatedCircle new CircleAdapter(circle); 创建实现了接口的类的对象或者从抽象类派生出具体的子类然后通过这些对象进行实例化。这也是多态的体现。
