Java面向对象

class Person {
    public void showData() {
        System.out.println("ROOT");
    }

    public void showText() {
        System.out.println("Hello，Person");
    }
}

class Text extends Person {
    public void showName() {
        System.out.println("Fox");
    }

    public void showText() {
        System.out.println("Hello，Text");
    }
}

class Demo {
    public static void main(String[] args) {
        Text v1 = new Text();   // 实例化一个子类方法 声明变量为子类类型
        v1.showText();  // 子类类型的子类方法，调用自身方法
        v1.showData();  // 子类类型的子类方法，调用父类方法

        Person v2 = new Text(); // 实例化一个子类方法 声明变量泛指父类类型
        v2.showData(); // 父类类型的子类方法，调用父类方法
        //v2.showName(); // 错误：泛指的父类类型中没有子类showName方法。
        v2.showText();  //虽然泛指父类类型，但按照实例中的方法执行结果>> Hello，Text

        Person v3 = new Person();   // 实例化一个父类方法 声明变量为父类类型
        v3.showText();  //父类调用自身方法
        v3.showData();  //父类调用自身方法
        //v3.showName(); //报错：父类中没有showName方法

        //Text v4 = new Person();     //错误：Person父类 缺少 Text子类 特有的方法和属性。
    }
}

class Demo2 {
    public static void doPerson(Person obj) {
        System.out.println(obj.getClass());
        obj.showText();
        obj.showData();
        //obj.showName(); //错误：传入的父类Person对象中没有子类的showName方法
    }


    public static void doText(Text obj) {
        obj.showText();
        obj.showData();
        obj.showName();
    }

    public static void main(String[] args) {
        // 多态
        doPerson(new Person()); //Hello，Person  ROOT
        doPerson(new Text());   //Hello，Text    ROOT


        //doText(new Person()); //报错：doText方法不能传入父类，因为父类不具备子类的方法
        doText(new Text()); //Hello，Text ROOT Fox
    }
}

public，公共，所有的只要有权限访问类,类中的成员都可以访问到。

private，私有，只允许自己类调用。

protected，同一个包 或 子类可以访问（即使没有在同一个包内，也可以访问父类中的受保护成员）。

default，只能在同一个包内访问。

Java类方法

class Raptor {
    // 静态字段（类变量）(类名.直接调用)
    public static String nation = "America";
    // 字段（实例变量）（使用this.调用）
    public String name;
    public Integer weight;

    // 构造方法，必须与类名相同,构造方法没有返回类型
    // 构造方法在创建对象时被调用，用于初始化对象的状态
    // 构造方法是通过 new 关键字来调用的，例如 new Raptor(123)
    public Raptor() {
        this.name = "Bald Eagle";
        this.weight = 5;
    }

    // Java重载 方法名可以重名，但参数不同
    // 使用Hook遇到重载默认报错，在方法名后加上.overload() 传入参数
    public Raptor(int v1) {
        this.weight = v1;
    }

    // 普通方法，必须指定返回类型（如果没有返回值，则使用 void）
    // 普通方法是通过对象实例来调用的，类的一个实例.Ra()
    public String Ra() {
        return Raptor.nation;
    }
}

class World {
    public static void main(String[] args) {
        Raptor r1 = new Raptor();
        System.out.println(r1.name);    // Bald Eagle
        Raptor r2 = new Raptor(123);
        System.out.println(r2.weight);  // 123

        String r3 = r1.Ra();
        System.out.println(r3); // America
    }
}

Java接口

interface IPerson {
    public void func1();

    public void func2();
}

class Ia implements IPerson {
    public void func1() {
        System.out.println("I1");
    }

    public void func2() {
        System.out.println("I2");
    }

    public void func3() {
        System.out.println("I3");
    }
}

class IDemo {
    public static void main(String[] args) {
        IPerson v1 = new Ia();
        v1.func1();
        Ia v2 = new Ia();
        v2.func3();
    }
}

Java抽象类

abstract class Shape {
    // 抽象方法
    public abstract double area();
}

// 子类1
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// 子类2
class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

// 测试类
class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        System.out.println("Circle area: " + circle.area());

        Shape rectangle = new Rectangle(3, 4);
        System.out.println("Rectangle area: " + rectangle.area());
    }
}