怎么用html做移动网站吗,为外国企业做中文网站建设,魏县住房和城乡建设局网站,公司营销型网站制作前言#xff1a; 抽象类#xff0c;接口#xff0c;内部类 文章目录 一、抽象类1.1 抽象方法1.2 抽象类1.3 抽象类的使用 二、 接口2.1 接口的定义和实现2.2 default 关键字2.3 实现接口时遇到的问题 三、内部类3.1 成员内部类3.2 静态内部类3.3 成员内部类3.4 匿名内部类 抽象类接口内部类 文章目录 一、抽象类1.1 抽象方法1.2 抽象类1.3 抽象类的使用 二、 接口2.1 接口的定义和实现2.2 default 关键字2.3 实现接口时遇到的问题 三、内部类3.1 成员内部类3.2 静态内部类3.3 成员内部类3.4 匿名内部类最常用 一、抽象类 在Java中抽象类是一种不能被实例化的类它通常用于定义一些共用的方法和字段在该类中不知道具体的实现但还是想让子类必须去实现这些方法所以将成员方法定义成抽象方法该类定义成抽象类。abstract 用于修饰方法方法和类修饰的方法是抽象方法修饰的类是抽象类。 1.1 抽象方法
使用abstract 关键字修饰方法该方法就成了抽象方法抽象方法只包含一个方法名而没有方法体。
定义格式
修饰符 abstract 返回值类型 方法名 (参数列表);示例:
public abstract void run();1.2 抽象类
使用abstract 关键字修饰类
形式:
abstract class 类名字 { }示例:
public abstract class Animal {public abstract void run()
}注意抽象类不一定有抽象方法但有抽象方法的类一定要定义成抽象类
1.3 抽象类的使用 继承抽象类 如果一个类继承了一个抽象类并且这个类不是抽象类那么它必须实现所有从抽象类继承的抽象方法。如果一个类继承了一个抽象类但没有实现所有的抽象方法那么这个类必须声明为抽象类。 抽象类的继承链 一个抽象类可以继承另一个抽象类并且可以选择性地实现部分或全部继承的抽象方法。最终必须有一个具体非抽象的子类实现所有抽象方法。
示例代码 子类实现所有抽象方法 abstract class Animal {abstract void makeSound();abstract void eat();
}class Dog extends Animal {Overridevoid makeSound() {System.out.println(Woof!);}Overridevoid eat() {System.out.println(Dog is eating.);}
}public class Main {public static void main(String[] args) {Animal myDog new Dog();myDog.makeSound();myDog.eat();}
}Dog类继承了Animal类并且实现了所有的抽象方法。 子类没有实现所有抽象方法必须声明为抽象类 abstract class Animal {abstract void makeSound();abstract void eat();
}abstract class Canine extends Animal {Overridevoid makeSound() {System.out.println(Howl!);}// eat 方法没有实现所以 Canine 仍然是抽象类
}class Dog extends Canine {Overridevoid eat() {System.out.println(Dog is eating.);}
}public class Main {public static void main(String[] args) {Animal myDog new Dog();myDog.makeSound();myDog.eat();}
}Canine类实现了makeSound方法但没有实现eat方法因此Canine必须声明为抽象类。Dog类继承了Canine并实现了eat方法使得Dog成为具体类可以被实例化。 二、 接口 接口Interface在Java中是一个重要的概念用于定义一组方法的规范而不提供任何实现。接口主要用于定义类之间的契约和规范确保实现这些接口的类遵循相同的方法签名。 2.1 接口的定义和实现
接口的定义 接口使用interface关键字定义接口中的所有方法默认是public和abstract所有成员变量默认是public static final。以下是一个简单的接口示例
public interface Animal {void makeSound();void eat();
}实现接口 类通过implements关键字实现接口一个类可以实现多个接口这与抽象类的单继承限制不同。以下是实现Animal接口的两个类
public class Dog implements Animal {Overridepublic void makeSound() {System.out.println(Woof!);}Overridepublic void eat() {System.out.println(Dog is eating.);}
}public class Cat implements Animal {Overridepublic void makeSound() {System.out.println(Meow!);}Overridepublic void eat() {System.out.println(Cat is eating.);}
}类实现接口的要求
必须重写实现的全部接口中所有抽象方法。如果一个类实现了接口但是没有重写完全部接口的全部抽象方法这个类也必须定义成抽象类。
如果一个类实现了多个接口而这些接口有相同的抽象方法那么这个类只需要实现这个抽象方法一次即可因为Java不允许同一个类中出现重复的方法签名。这种情况下类只需要提供一次方法的实现而不需要重复实现多次。 2.2 default 关键字 default 关键字主要用于接口中的默认方法default methods这是从Java 8开始引入的特性。默认方法允许在接口中为方法提供默认的实现这样可以在不破坏现有实现的情况下向接口添加新的方法。 默认方法Default Methods定义方式
public interface InterfaceName {// 抽象方法void regularMethod();// 默认方法default void defaultMethod() {// 默认实现System.out.println(This is a default method.);}
}在上面的例子中defaultMethod 就是一个默认方法。默认方法使用 default 关键字修饰它提供了一个默认的实现。所有实现了这个接口的类都会继承这个默认方法如果需要的话可以在实现类中重写默认方法。
示例
public interface Vehicle {void start();default void honk() {System.out.println(Vehicle is honking.);}
}public class Car implements Vehicle {Overridepublic void start() {System.out.println(Car is starting.);}// Car可以选择不重写honk方法使用默认实现
}public class Bike implements Vehicle {Overridepublic void start() {System.out.println(Bike is starting.);}Overridepublic void honk() {System.out.println(Bike is honking.); // Bike提供了自己的honk方法实现}
}当需要扩展一个接口但又不能破坏所有实现这个接口的类时可以使用默认方法。
注意事项: 如果一个类实现了多个接口而这些接口有相同的默认方法实现类必须重写这个默认方法来解决冲突。
interface A {default void hello() {System.out.println(Hello from A);}
}interface B {default void hello() {System.out.println(Hello from B);}
}class C implements A, B {Overridepublic void hello() {A.super.hello(); // 明确指定调用接口A的默认方法//B.super.hello(); 或明确指定调用接口B的默认方法}
}2.3 实现接口时遇到的问题 如果一个类继承了一个类并实现了一个接口且父类和接口中有都有相同签名的方法。 处理办法一如果父类中的方法体能满足当前业务的需求在子类中可以不用重写。处理办法二如果父类中的方法体不能满足当前业务的需求需要在子类中重写。 如果一个接口中有多个抽象方法但在实现类中只需要用其中一个或部分 方法一实现类声明为抽象类 你可以将实现类声明为抽象类并只实现部分抽象方法这样子类就可以根据需要选择性地实现接口的方法。 // 定义一个接口
interface MyInterface {void method1(); // 抽象方法1void method2(); // 抽象方法2void method3(); // 抽象方法3
}// 实现类声明为抽象类并只实现部分方法
abstract class MyAbstractClass implements MyInterface {Overridepublic void method1() {System.out.println(Implemented method1);}// 不需要实现 method2 和 method3
}// 子类继承抽象类选择性实现部分方法
class MyClass extends MyAbstractClass {Overridepublic void method2() {System.out.println(Implemented method2);}
}方法二使用适配器模式Adapter Pattern 如果不想使用抽象类可以使用适配器模式它允许提供接口的默认实现然后子类可以选择性地覆盖它们。 // 定义一个接口
interface MyInterface {void method1(); // 抽象方法1void method2(); // 抽象方法2void method3(); // 抽象方法3
}// 创建适配器类提供接口的默认实现
abstract class MyInterfaceAdapter implements MyInterface {Overridepublic void method1() {// 默认实现}Overridepublic void method2() {// 默认实现}Overridepublic void method3() {// 默认实现}
}// 子类选择性地覆盖需要的方法
class MyClass extends MyInterfaceAdapter {Overridepublic void method2() {System.out.println(Implemented method2);}
}三、内部类 内部类Inner Class是定义在另一个类内部的类。Java 提供了多种内部类包括成员内部类、局部内部类、匿名内部类和静态内部类。 按定义的位置来分
成员内部内类定义在了成员位置 (类中方法外称为成员位置无static修饰的内部类)静态内部类类定义在了成员位置 (类中方法外称为成员位置有static修饰的内部类)局部内部类类定义在方法内匿名内部类没有名字的内部类可以在方法中也可以在类中方法外。 3.1 成员内部类
定义格式:
class OuterClass {class InnerClass {// Inner class members}
}内部类的使用格式 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类创建内部类实例 方式一外部直接创建成员内部类的对象 OuterClass outer new OuterClass();
OuterClass.InnerClass inner outer.new InnerClass();
//或
OuterClass.InnerClass inner new OuterClass().new InnerClass();方法二在外部类中定义一个方法提供内部类的对象 public class Outer {private class Inner{}public Inner getInstance(){return new Inner();}
}public class Test {public static void main(String[] args) {Outer outer new Outer();Inner inner outer.getInstance();}
}成员内部类的细节 成员内部类可以被一些修饰符所修饰比如 private默认protectedpublicstatic等 成员内部类可以访问外部类的所有成员包括私有成员。这是因为成员内部类持有一个对外部类实例的引用Outer.this。 public class Outer {private String outerField Outer field;class Inner {void display() {System.out.println(Inner class accessing: outerField);System.out.println(Inner class accessing through Outer.this: Outer.this.outerField);}}public static void main(String[] args) {Outer outer new Outer(); // 创建外部类对象Outer.Inner inner outer.new Inner(); // 创建内部类对象inner.display(); // 调用内部类的方法}
}//输出:
Inner class accessing: Outer field
Inner class accessing through Outer.this: Outer field内存图示例: 在 JDK 8 之前局部变量必须显式声明为 final 才能被成员内部类。在 JDK 8 及之后只要局部变量在初始化后没有被修改它们就被隐式地视为 final即有效 final不再需要显式声明为 final。 3.2 静态内部类
定义格式
class OuterClass {static class StaticInnerClass {// 静态内部类的成员}
}创建实例
OuterClass.StaticInnerClass innerObject new OuterClass.StaticInnerClass();静态内部类的特点 静态内部类可以直接访问外部类的静态成员但不能访问外部类的非静态成员如果要访问需要创建外部类的对象用对象调用。 public class Outer {private static String staticOuterField Static Outer Field;private String nonStaticOuterField Non-Static Outer Field;static class StaticInner {void display() {// 静态内部类可以访问外部类的静态成员System.out.println(Static Inner Class accessing static outer field: staticOuterField);// 但不能直接访问外部类的非静态成员// System.out.println(Static Inner Class accessing non-static outer field: nonStaticOuterField); // 编译错误}}public static void main(String[] args) {// 创建静态内部类的实例StaticInner inner new StaticInner();inner.display(); // Output: Static Inner Class accessing static outer field: Static Outer Field// 如果要访问外部类的非静态成员需要创建外部类的对象Outer outer new Outer();System.out.println(Access non-static outer field through outer object: outer.nonStaticOuterField);}
}无需外部类实例 可以直接创建静态内部类的实例而不需要外部类的实例。 :静态内部类中没有隐含的 Outer.this。 3.3 成员内部类 局部内部类是定义在方法或作用域内部的内部类。 特点
作用域限制 局部内部类的作用域仅限于定义它的方法或代码块中不能在外部访问。访问权限 局部内部类可以访问外部类的所有成员包括私有成员。访问局部变量 局部内部类可以访问方法内的 final 局部变量JDK 8版本可以访问非 final 的局部变量但其值不能在局部类中被修改。生命周期 局部内部类的生命周期仅限于方法调用方法结束后局部内部类实例也会被销毁。
示例
public class Outer {private int outerField 10;public void methodWithLocalInnerClass() {final int localVar 20; // JDK 8 可以不用final修饰但不可变class LocalInner {void display() {System.out.println(Outer field: outerField);System.out.println(Local variable: localVar);}}// 创建局部内部类的实例并调用方法LocalInner inner new LocalInner();inner.display();}public static void main(String[] args) {Outer outer new Outer();outer.methodWithLocalInnerClass();}
}3.4 匿名内部类最常用 匿名内部类是一种没有显式声明类名的内部类它在创建对象的同时定义类的实现。匿名内部类通常用于创建只需使用一次且没有额外的逻辑的类实例。 格式
new 类名或者接口名() {重写方法;
};
这里同时包含了继承或实现方法重写创建对象
从new关键字到;整个整体是匿名内部类的实例{}内的是匿名内部类没有类名使用 以接口为例匿名内部类的使用代码如下
interface Swim {public abstract void swimming();
}public class Test {public static void main(String[] args) {// 接口 变量 new 实现类(); // 多态,走子类的重写方法Swim s2 new Swim() {Overridepublic void swimming() {System.out.println(蛙泳...);}};s2.swimming();}
}如果你喜欢这篇文章点赞评论关注⭐️哦 欢迎大家提出疑问以及不同的见解。
