Java笔记5——面向对象（下）

目录

一、抽象类和接口 

1-1、抽象类（包含抽象方法的类）

1-2、接口

​编辑​编辑

二、多态

​编辑

1. 自动类型转换（向上转型）

示例：

注意：

2. 强制类型转换（向下转型）

示例：

注意：

3. 类型转换的注意事项

4、instanceof 关键字：

总结

 三、Object类

 四、内部类

 内部类的作用

4-1、成员内部类 

4-2、局部内部类

 4-3、静态内部类

4-4、匿名内部类 

---

 

 

一、抽象类和接口 

• 抽象类：是一个半成品的模具，提供了一个通用的框架，但需要子类来完成具体的实现。

• 接口：是一个协议，定义了一组行为，但不关心这些行为是如何实现的。

1-1、抽象类（包含抽象方法的类）

        抽象类中的某些方法是抽象的（没有具体实现），这些方法就像是模具上的预留孔，等待子类（具体的物品）来填充。————就相当于自定义功能实现区入口，同一种功能不同的对象实现效果不一样（如：发出声音这个功能，狗发出的声音是汪，而猫发出的声音是喵），实现效果不同则实现方法不同。

 代码示例

//定义抽象类Animal
abstract class Animal {//定义抽象方法shout()abstract void shout();
}//定义Dog类继承抽象类Animal
class Dog extends Animal {//重写抽象方法shout()void shout() {System.out.println("汪，汪……");}
}
class Cat extends Animal {//重写抽象方法shout()void shout() {System.out.println("喵，喵……");}
}//定义测试类
public class Example10 {public static void main(String[] args) {Dog dog = new Dog(); //创建Dog类的对象Cat cat = new Cat();dog.shout(); //通过dog对象调用shout()方法cat.shout();//通过cat对象调用shout()方法}
}

输出

 注意：使用abstract关键字修饰的抽象方法不能使用private修饰，因为抽象方法必须被子类实现，如果使用了private关键字修饰抽象方法，则子类无法实现该方法。

1-2、接口

 接口（Interface） 接口就像是一个协议。它定义了一组规则或行为，但不关心这些行为是如何实现的。任何实现了这个接口的类都必须遵守这个协议，提供接口中定义的所有方法的实现。

 代码示例

//定义接口Animal
interface Animal {int ID = 1; //定义全局常量，编号String NAME = "牧羊犬"; //定义全局常量，名称void shout(); //定义抽象方法shout()public void info(); //定义抽象方法info()static int getID() { //定义静态方法getID(),用于返回ID值return Animal.ID;}
}interface Action { //定义抽象方法eat()public void eat();
}//定义Dog类实现Animal接口和Action接口
class Dog implements Animal, Action {//重写Action接口中的抽象方法eat()public void eat() {System.out.println("喜欢吃骨头");}//重写Animal接口中的抽象方法shout()public void shout() {System.out.println("汪汪……");}//重写Animal接口中的抽象方法info()public void info() {System.out.println("名称:" + NAME);}
}//定义测试类
class Example11 {public static void main(String[] args) {System.out.println("编号" + Animal.getID());Dog dog = new Dog(); //创建Dog类的实例对象dog.info(); //调用Dog类中重写的info()方法dog.shout(); //调用Dog类中重写的shout()方法dog.eat(); //调用Dog类中重写的eat()方法}
}

输出

// 定义接口 Animal
interface Animal {public String NAME = "牧羊犬"; // 定义全局常量，名称public void shout(); // 定义抽象方法 shout()public void info(); // 定义抽象方法 info()
}// 定义抽象类 Action
abstract class Action {public abstract void eat(); // 定义抽象方法 eat()
}// 定义 Dog 类继承 Action 抽象类，并实现 Animal 接口
class Dog extends Action implements Animal {// 重写 Action 抽象类中的抽象方法 eat()public void eat() {System.out.println("喜欢吃骨头");}// 重写 Animal 接口中的抽象方法 shout()public void shout() {System.out.println("汪汪……");}// 重写 Animal 接口中的抽象方法 info()public void info() {System.out.println("名称:"+NAME);}
}// 定义测试类
class Example12 {public static void main(String[] args) {Dog dog = new Dog(); // 创建 Dog 类的实例对象dog.info(); // 调用 Dog 类中重写的 info() 方法dog.shout(); // 调用 Dog 类中重写的 shout() 方法dog.eat(); // 调用 Dog 类中重写的 eat() 方法}
}

 输出：

 注意：在JAVA中，接口不允许继承抽象类，但是允许接口继承接口，并且一个接口可以继承多个接口。

示例：

// 定义接口 Animal
interface Animal {public String NAME = "牧羊犬"; // 定义常量 NAMEpublic void info(); // 定义抽象方法 info()
}// 定义 Color 接口
interface Color {public void black(); // 定义抽象方法 black()
}// 定义 Action 接口，它同时继承 Animal 接口和 Color 接口
interface Action extends Animal, Color {public void shout(); // 定义抽象方法 shout()
}// 定义 Dog 类实现 Action 接口
class Dog implements Action {// 重写 Animal 接口中的抽象方法 info()public void info() {System.out.println("名称:" + NAME);}// 重写 Color 接口中的抽象方法 black()public void black() {System.out.println("黑色");}// 重写 Action 接口中的抽象方法 shout()public void shout() {System.out.println("汪汪……");}
}// 定义测试类
class Example13 {public static void main(String[] args) {Dog dog = new Dog(); // 创建 Dog 类的 dog 对象dog.info(); // 调用 Dog 类中重写的 info() 方法dog.shout(); // 调用 Dog 类中重写的 shout() 方法dog.black(); // 调用 Dog 类中重写的 black() 方法}
}

二、多态

// 定义抽象类 Animal
abstract class Animal {abstract void shout(); // 定义抽象 shout() 方法
}// 定义 Cat 类继承 Animal 抽象类
class Cat extends Animal {// 重写 shout() 方法public void shout() {System.out.println("喵喵……");}
}// 定义 Dog 类继承 Animal 抽象类
class Dog extends Animal {// 重写 shout() 方法public void shout() {System.out.println("汪汪……");}
}// 定义测试类
public class Example14 {public static void main(String[] args) {Animal an1 = new Cat(); // 创建 Cat 类的对象并转型为 Animal 类的对象Animal an2 = new Dog(); // 创建 Dog 类的对象并转型为 Animal 类的对象an1.shout(); // 调用 Cat 类中重写的 shout() 方法an2.shout(); // 调用 Dog 类中重写的 shout() 方法}
}

 

Java 中的对象类型转换是面向对象编程中的一个重要概念，它允许我们将一个对象从一种类型转换为另一种类型。

类型转换可以分为 自动类型转换 和 强制类型转换，具体取决于上下文和对象之间的继承关系。

1. 自动类型转换（向上转型）

向上转型是指将子类对象转换为父类类型。这种转换是安全的，因为子类继承了父类的所有属性和方法，因此可以直接赋值给父类引用。

示例：

class Animal {void eat() {System.out.println("Animal is eating");}
}class Dog extends Animal {void bark() {System.out.println("Dog is barking");}
}public class Main {public static void main(String[] args) {Dog dog = new Dog(); // 创建 Dog 对象Animal animal = dog; // 自动向上转型为 Animal 类型animal.eat(); // 调用父类方法// animal.bark(); // 错误：Animal 类型没有 bark() 方法}
}

注意：

• 向上转型后，父类引用只能访问父类的方法和属性，无法访问子类特有的方法。

• 如果需要访问子类特有的方法，需要进行向下转型。

2. 强制类型转换（向下转型）

向下转型是指将父类对象转换为子类类型。这种转换需要显式地进行，并且只有在对象的实际类型是子类时才安全。如果对象的实际类型不是子类，会抛出 ClassCastException。

示例：

public class Main {public static void main(String[] args) {Dog dog = new Dog();Animal animal = dog; // 向上转型//制向下转型Dog dog2 = (Dog) animal;dog2.bark(); // 可以调用子类特有的方法}
}

注意：

• 强制类型转换前，最好使用 instanceof 关键字检查对象的实际类型，以避免异常。

• 示例

  if (animal instanceof Dog) {Dog dog2 = (Dog) animal;
  }

3. 类型转换的注意事项

1. 类型兼容性：

   • 只有存在继承关系的类之间才能进行类型转换。

   • 例如，Integer 和 String 之间没有继承关系，不能互相转换。

4、instanceof 关键字：

如果对象是指定的类或接口的示例对象，则返回true,否则返回false  

用于检查一个对象是否是某个类的实例。

示例

if (animal instanceof Dog) {Dog dog = (Dog) animal;
}

// 定义 Animal 类
class Animal {public void shout() {System.out.println("动物叫……");}
}// 定义 Dog 类
class Dog extends Animal {// 重写 shout() 方法public void shout() {System.out.println("汪汪……");}public void eat() {System.out.println("吃骨头……");}
}// 定义测试类
public class Example17 {public static void main(String[] args) {Animal a1 = new Dog(); // 通过向上转型实例化 Animal 对象System.out.println("Animal a1 = new Dog() : " + (a1 instanceof Animal));System.out.println("Animal a1 = new Dog() : " + (a1 instanceof Dog));Animal a2 = new Animal(); // 实例化 Animal 对象System.out.println("Animal a2 = new Animal() : " + (a2 instanceof Animal));System.out.println("Animal a2 = new Animal() : " + (a2 instanceof Dog));}
}

输出 

总结

Java 中的对象类型转换主要包括向上转型和向下转型：

• 向上转型：安全，自动完成，用于多态。

• 向下转型：需要显式转换，必须确保对象的实际类型是目标类型，否则会抛出异常。

在实际开发中，合理使用类型转换可以提高代码的灵活性和可维护性，但需要注意类型兼容性和安全性问题。

 三、Object类

示例代码

// 定义 Animal 类
class Animal {// 定义动物叫的方法void shout() {System.out.println("动物叫！");}
}// 定义测试类
public class Example18 {public static void main(String[] args) {Animal animal = new Animal(); // 创建 Animal 类对象System.out.println(animal.toString()); // 调用 toString() 方法并打印}
}

 一般情况下不会直接调用Object类中的方法，因为Object类中的方法并不适用于所有的子类，这时就需要对Object类中的方法进行重写，以满足实际开发需求。

例如：重写toString()方法

// 定义 Animal 类
class Animal {// 重写 Object 类的 toString() 方法public String toString() {return "这是一个动物。";}
}// 定义测试类
public class Example19 {public static void main(String[] args) {Animal animal = new Animal(); // 创建 animal 对象System.out.println(animal.toString()); // 调用 toString() 方法并打印}
}

 

 四、内部类

Java 内部类（Inner Class）是一种特殊的类定义方式，它允许在一个类的内部定义另一个类。

内部类可以分为以下几种类型：

• 成员内部类：定义在类的内部，但不在任何方法中。

• 局部内部类：定义在方法或代码块中。

• 匿名内部类：没有类名的内部类，通常用于实现接口或继承类。

• 静态内部类：使用 static 关键字修饰的内部类。

 

 内部类的作用

(1) 逻辑分组

内部类可以将相关的类组织在一起，增强代码的逻辑性和可读性。例如，一个类的主要功能可以通过外部类实现，而辅助功能可以通过内部类实现。

(2) 访问控制

内部类可以访问外部类的成员变量和方法（包括私有成员）。这使得内部类能够更好地与外部类交互，实现更紧密的耦合。

(3) 实现回调

内部类常用于实现回调机制。例如，在 GUI 编程中，内部类可以用来处理事件（如按钮点击事件）。

(4) 多继承的替代

Java 不支持多重继承，但通过内部类可以实现类似的效果。内部类可以继承一个类，同时外部类可以继承另一个类。

(5) 代码复用

内部类可以被外部类的多个实例共享，从而提高代码的复用性。

(6) 简化代码

内部类可以简化某些复杂的代码结构，尤其是在需要实现接口或继承类时。

4-1、成员内部类 

代码示例 

class Outer {int m = 0; // 定义类的成员变量// 外部类方法 test1()void test1() {System.out.println("外部类成员方法 test1()");}// 下面的代码定义了成员内部类 Innerclass Inner {int n = 1;void show1() {// 在成员内部类的方法中访问外部类的成员变量 mSystem.out.println("外部类成员变量 m = " + m);// 在成员内部类的方法中访问外部类的成员方法 test1()test1();}void show2() {System.out.println("内部类成员方法 show2()");}}// 外部类方法 test2()void test2() {Inner inner = new Inner(); // 实例化内部类对象 innerSystem.out.println("内部类成员变量 n = " + inner.n); // 访问内部类变量和方法inner.show2();}
}public class Example20 {public static void main(String[] args) {Outer outer = new Outer(); // 实例化外部类对象 outerOuter.Inner inner = outer.new Inner(); // 实例化内部类对象 innerinner.show1(); // 在内部类中访问外部类的成员变量 m 和成员方法 test1()outer.test2(); // 在内部类中访问内部类的成员变量 n 和成员方法 show2()}
}

输出

4-2、局部内部类

class Outer {int m = 0; // 定义类的成员变量// 定义一个成员方法 test1()void test1() {System.out.println("外部类成员方法 test1()");}void test2() {// 定义一个局部内部类，在局部内部类中访问外部类变量和方法class Inner {int n = 1;void show() {System.out.println("外部类成员变量 m = " + m);test1();}}// 访问局部内部类中的变量和方法Inner inner = new Inner();System.out.println("局部内部类变量 n = " + inner.n);inner.show();}
}public class Example21 {public static void main(String[] args) {Outer outer = new Outer(); // 实例化外部类对象 outerouter.test2(); // 通过外部类对象 outer 调用创建了局部内部类的方法 test2()}
}

输出

 4-3、静态内部类

class Outer {static int m = 0; // 定义类的静态变量// 下面的代码定义了一个静态内部类static class Inner {int n = 1;void show() {// 在静态内部类的方法中访问外部类的静态变量 mSystem.out.println("外部类静态变量 m = " + m);}}
}public class Example22 {public static void main(String[] args) {Outer.Inner inner = new Outer.Inner(); // 创建静态内部类的对象inner.show(); // 调用静态内部类的方法}
}

输出

4-4、匿名内部类 

interface Animal { // 定义接口 Animalvoid shout(); // 定义抽象方法 shout()
}public class Example23 {public static void main(String[] args) {String name = "小花";animalShout(new Animal() { // 调用 animalShout() 方法，参数为匿名内部类@Override // 重写接口中的方法public void shout() {System.out.println(name + "喵喵……");}});}public static void animalShout(Animal an) { // 该方法参数为 Animal 接口类型an.shout();}
}