三，Java面向对象的特点其三：多态

Java面向对象：深入理解多态性

在Java编程中，多态性（Polymorphism）是指同一个事物在不同时刻下的不同状态。多态性是面向对象编程中的一个重要概念，它允许我们根据需要在运行时动态地改变对象的行为。

多态概述

多态允许一个类有多个形态，即在运行时可以改变对象的行为。多态性是继承和方法重载的结合，它允许子类根据需要改变其行为。即父类的引用指向子类对象

实现多态的前提

1. 继承关系：子类必须继承自父类。
2. 方法重载：子类可以重写父类中的方法，以更好地体现子类的特点。
3. 父类引用：子类需要有一个引用指向父类对象，以便调用父类的方法和访问父类的成员变量。

访问成员的特点

• 成员变量：编译时看左边，运行时看左边。
• 成员方法：编译时看左边，运行时看右边。
• 静态成员方法：编译时看左边，运行时看左边。

多态的好处

1. 提高代码的维护性：通过继承，子类可以复用父类的代码，减少了代码的重复。
2. 提高代码的扩展性：通过方法重载，子类可以扩展父类的行为，增加新功能。

示例代码

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        animal.makeSound(); // 输出: Some sound
        dog.makeSound(); // 输出: Bark
       cat.makeSound(); // 输出: Meow
    }
}

在这个例子中，Animal类定义了一个makeSound方法，Dog类和Cat类分别重载了这个方法，提供了不同的实现。PolymorphismExample类中的代码创建了Animal、Dog和Cat对象，并调用它们的makeSound方法，输出不同的声音。

总结

多态是Java中实现动态行为改变的一种机制，它允许子类根据需要改变其行为。通过理解多态，我们可以编写更加灵活和可扩展的代码。这些概念是Java编程中不可或缺的部分，掌握它们对于编写高质量、可维护的代码至关重要。

多态性与向下转型详解

在Java编程中，多态性（Polymorphism）允许一个类有多种不同的表现形式。向下转型（Downcasting）是多态性的一个重要应用，它允许我们将一个父类的引用指向子类的对象。本文将详细探讨Java中的多态性以及向下转型的概念、使用和示例。

向下转型

向下转型是指将子类的引用赋值给父类的引用，这是多态性的一种表现形式。由于Java的继承关系，子类是父类的一个特化，因此子类对象可以被视为父类对象。

示例代码

//多态(父类的引用指向子类对象)
// 向下转型(父类的引用转成子类对象)
//可以解决多态只能访问和父类一样的方法，不能访问子类自己的方法的问题
class Fu2{

    public void fun1(){
        System.out.println("吃饭");
    }
    public static void fun3(){
        System.out.println("打游戏");
    }
}

class Zi2 extends Fu2{
    @Override
    public void fun1() {
        System.out.println("睡觉");
    }
    public void fun2(){
        System.out.println("打豆豆");
    }
}

class Demo1 extends Fu2{

}

public class Demo06DuoTai05{
    public static void main(String[] args) {
        //多态：父类的引用指向子类对象
        Fu2 f2 = new Zi2();
        f2.fun1();//多态访问成员方法时编译看左，运行看右---编译：左边父类中右fun1方法  运行：右边子类中的fun1方法
        f2.fun3();//多态访问静态的成员方法时编译看左，运行看左---编译：左边父类中有fun3  运行：左边......

         //f2.fun2;//多态访问成员方法时编译看左，运行看右---编译：左边父类中没有fun2方法就会报错
        // 若想不再new的情况下调用fun2，就要向下转型（父类是上，子类是下），Fu2 f2 = new Zi2();就相当于向上转型（从右向左看）
        //向下转型格式：子类类名 变量名 = （子类类名） 要转型的变量名；
        Zi2 z2 =(Zi2)f2;
        z2.fun2();
        //只有当两个类具有继承关系或者是实现关系才可以详细转型
//        Demo1 d1 = (Demo1)f2;//（继承关系）例如这里的Demo1没有继承就不能向下转型
//        Demo1 d1 = (Demo1) f2;//（实现关系）例如这里Demo1是继承之后的，但是Demo1和Zi1间没有关系，
//                             // 只有实际内存对象类型Zi1与要转的类型一样才行
        Fu2 f = new Demo1();
        Demo1 d = (Demo1)f;

    }
}

总结

多态性是Java中实现代码复用和组织结构的重要手段，它允许开发者构建具有层次结构的代码，使得代码更加模块化和易于管理。向下转型是多态性的一个重要应用，它允许我们将子类对象视为父类对象，从而实现代码的复用和扩展性。理解多态性对于编写高质量、可维护的代码至关重要。通过掌握多态性，我们可以编写更加灵活和可扩展的代码结构。

抽象类与方法

在Java编程中，抽象类和抽象方法是实现多态性和代码复用性的重要概念。抽象类提供了一个模板，而抽象方法则定义了必须由子类实现的行为。本文将详细探讨Java中的抽象类和抽象方法，包括它们的使用、特点和示例代码。

抽象类

抽象类是使用abstract关键字修饰的类，它不能被实例化，但可以被继承。

特点

1. 抽象类不能实例化：抽象类不能直接创建对象。
2. 包含抽象方法：抽象类可以包含没有实现的方法。
3. 子类必须实现抽象方法：继承抽象类的子类必须实现父类中所有的抽象方法。
4. 抽象类可以包含具体方法：抽象类可以包含具体实现的方法。

示例代码

abstract class Animal {
    abstract void makeSound();
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class AbstractExample {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // 输出: Dog barks
        animal.eat(); // 输出: Animal is eating
    }
}

抽象方法

抽象方法是使用abstract关键字修饰的方法，它没有具体的实现，必须在子类中被重写。

特点

1. 抽象方法没有实现：抽象方法没有大括号实现。
2. 子类必须重写抽象方法：子类必须提供抽象方法的具体实现。
3. 抽象类可以包含具体方法：抽象类可以包含具体实现的方法。

示例代码

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

public class AbstractExample {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw(); // 输出: Drawing a circle
    }
}

总结

抽象类和抽象方法为Java编程提供了强大的多态性支持，允许开发者定义通用的模板和行为，然后由子类根据需要实现具体的功能。这些概念是Java面向对象编程中不可或缺的部分，掌握它们对于编写可复用、可维护的代码至关重要。通过理解和正确使用抽象类和抽象方法，我们可以构建更加灵活和可扩展的代码结构。

接口（Interface）详解

在Java编程中，接口（Interface）是一种特殊的抽象类型，它定义了一组方法规范，但不提供具体实现。接口允许类实现这些方法规范，从而实现多态性。

接口概述

接口用于定义一组方法规范，这些方法在接口中声明为抽象方法，没有具体实现。类通过实现接口来提供这些方法的具体实现。

特点

1. 抽象方法：接口中的方法默认为public abstract，即没有方法体。
2. 常量：接口中可以定义常量，默认使用public static final修饰。
3. 继承关系：接口之间是继承关系，一个接口可以继承多个接口。
4. 实现关系：类和接口之间是实现关系，一个类可以实现多个接口。

示例代码

interface Drawable {
    void draw(); // 抽象方法
}

interface Clickable {
    void click(); // 抽象方法
}

class Button implements Drawable, Clickable {
    public void draw() {
        System.out.println("Drawing a button");
    }
    public void click() {
        System.out.println("Button clicked");
    }
}

public class TestInterface {
    public static void main(String[] args) {
        Button button = new Button();
        button.draw(); // 输出: Drawing a button
        button.click(); // 输出: Button clicked
    }
}

在这个例子中，Button类实现了Drawable和Clickable接口，并提供了draw和click方法的具体实现。

接口的注意事项

1. 抽象方法：接口中的方法默认是抽象的，没有方法体。
2. 常量：接口中定义的常量默认是public static final。
3. 继承：接口可以继承多个接口，形成多态结构。
4. 实现：类可以实现多个接口，但必须提供接口中所有抽象方法的具体实现。

接口与抽象类的区别

• 抽象类：可以包含具体方法的实现，可以有构造方法，可以包含成员变量。
• 接口：只包含抽象方法和常量，没有构造方法，没有成员变量。

总结

接口是Java中实现多态性的重要机制，它允许类实现一组方法规范，而不需要提供具体实现。通过接口，我们可以定义一组行为规范，然后由不同的类来实现这些规范，从而实现代码的复用和扩展性。接口是Java编程中不可或缺的部分，掌握它们对于编写高质量、可维护的代码至关重要。通过理解和正确使用接口，我们可以构建更加灵活和可扩展的代码结构。

---

深入理解权限修饰符与内部类(重点是匿名内部类)

在Java编程中，权限修饰符用于控制类、方法和变量的访问级别，而内部类则提供了一种在类内部定义类的方式，可以是面向对象的编程中常用的技术。本文将详细探讨Java中的权限修饰符和内部类，包括它们的使用和特点。

权限修饰符

Java提供了四种权限修饰符来控制访问级别：

• public：任何类都可以访问。
• protected：同一个包内的类或子类可以访问。
• 默认的（package-private）：同一个包内的类可以访问。
• private：只有定义它的类可以访问。

内部类

内部类是定义在另一个类内部的类，它提供了一种封装和隐藏实现细节的方式。

特点

1. 成员内部类：可以直接访问外部类的私有成员。
2. 局部内部类：只能被定义它的局部作用域访问。
3. 匿名内部类：没有名称，通常用于实现接口或抽象类的方法。

示例代码

public class Outer {
    private int outerField = 10;

    public class Inner {
        private int innerField = 20;

        public void accessOuterField() {
            System.out.println("Outer field: " + outerField);
        }
    }

    public void accessInnerField() {
        Inner inner = new Inner();
        System.out.println("Inner field: " + inner.innerField);
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.accessOuterField();
        outer.accessInnerField();
    }
}

在这个例子中，Outer类有一个私有成员outerField，Inner类可以访问它，而Inner类也有一个私有成员innerField，Outer类通过accessInner方法访问它。

匿名内部类

匿名内部类是没有名称的内部类，通常用于实现接口或抽象类的方法。

示例代码

public class Outer {
    public void doSomething() {
        new Runnable() {
            public void run() {
               System.out.println("Doing something");
           }
       }.run();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.doSomething();
    }
}

在这个例子中，Outer类有一个doSomething方法，它创建了一个匿名内部类实现了Runnable接口。

总结

权限修饰符和内部类是Java中控制访问级别和实现封装的重要工具。通过理解和正确使用这些概念，我们可以更好地组织代码，提高代码的安全性和可维护性。权限修饰符控制了类、方法和变量的可见性，而内部类提供了在类内部定义类的方式，允许我们隐藏实现细节并提供更灵活的代码结构。这些概念是Java编程中不可或缺的部分，掌握它们对于编写高质量、可维护的代码至关重要。