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

目录

一、抽象类和接口

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

1-2、接口

​编辑​编辑

二、多态

​编辑

[1. 自动类型转换（向上转型）](#1. 自动类型转换（向上转型）)

示例：

注意：

[2. 强制类型转换（向下转型）](#2. 强制类型转换（向下转型）)

示例：

注意：

[3. 类型转换的注意事项](#3. 类型转换的注意事项)

[4、instanceof 关键字：](#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 = "牧羊犬"; // 定义常量 NAME
    public 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()");
    }

    // 下面的代码定义了成员内部类 Inner
    class Inner {
        int n = 1;

        void show1() {
            // 在成员内部类的方法中访问外部类的成员变量 m
            System.out.println("外部类成员变量 m = " + m);
            // 在成员内部类的方法中访问外部类的成员方法 test1()
            test1();
        }

        void show2() {
            System.out.println("内部类成员方法 show2()");
        }
    }

    // 外部类方法 test2()
    void test2() {
        Inner inner = new Inner(); // 实例化内部类对象 inner
        System.out.println("内部类成员变量 n = " + inner.n); // 访问内部类变量和方法
        inner.show2();
    }
}

public class Example20 {
    public static void main(String[] args) {
        Outer outer = new Outer(); // 实例化外部类对象 outer
        Outer.Inner inner = outer.new Inner(); // 实例化内部类对象 inner
        inner.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(); // 实例化外部类对象 outer
        outer.test2(); // 通过外部类对象 outer 调用创建了局部内部类的方法 test2()
    }
}

输出

4-3、静态内部类

class Outer {
    static int m = 0; // 定义类的静态变量

    // 下面的代码定义了一个静态内部类
    static class Inner {
        int n = 1;

        void show() {
            // 在静态内部类的方法中访问外部类的静态变量 m
            System.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 { // 定义接口 Animal
    void 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();
    }
}