java子类如何继承父类属性的

子类继承父类属性的方法包括：使用extends关键字、调用父类构造方法、通过super关键字访问父类方法和属性。 其中，使用extends关键字定义子类是最常见的方法。接下来，我将详细介绍这些方法。

一、使用`extends`关键字

在Java中，子类通过使用extends关键字继承父类的属性和方法。这样，子类就可以拥有父类的所有非私有成员。以下是一个简单的示例：

class Parent {
    public String name;
    private int age;
    public Parent(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}
class Child extends Parent {
    public Child(String name, int age) {
        super(name, age);
    }
    public void displayChild() {
        display();
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child("John", 25);
        child.displayChild();
    }
}

在上述示例中，Child类通过extends关键字继承了Parent类的属性和方法。

二、调用父类构造方法

子类可以通过调用父类的构造方法来初始化继承自父类的属性。可以使用super关键字来调用父类的构造方法。示例代码如下：

class Parent {
    public String name;
    public Parent(String name) {
        this.name = name;
    }
}
class Child extends Parent {
    public int age;
    public Child(String name, int age) {
        super(name);
        this.age = age;
    }
}

在上述代码中，Child类调用了父类Parent的构造方法，通过super(name)来初始化name属性。

三、通过`super`关键字访问父类方法和属性

子类可以使用super关键字来访问和调用父类的属性和方法。以下是一个示例：

class Parent {
    public String name;
    public Parent(String name) {
        this.name = name;
    }
    public void display() {
        System.out.println("Parent Name: " + name);
    }
}
class Child extends Parent {
    public String name;
    public Child(String parentName, String childName) {
        super(parentName);
        this.name = childName;
    }
    public void display() {
        super.display();
        System.out.println("Child Name: " + name);
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child("John Sr.", "John Jr.");
        child.display();
    }
}

在上述代码中，Child类通过super.display()调用了Parent类的display方法，并通过super.name访问父类的name属性。

四、重写父类方法

子类可以重写父类的方法，以提供子类特定的实现。这是面向对象编程中多态性的重要体现。以下是一个示例：

class Parent {
    public void display() {
        System.out.println("This is the Parent class.");
    }
}
class Child extends Parent {
    @Override
    public void display() {
        System.out.println("This is the Child class.");
    }
}
public class Main {
    public static void main(String[] args) {
        Parent parent = new Parent();
        parent.display();
        Child child = new Child();
        child.display();
    }
}

在上述代码中，Child类重写了Parent类的display方法。

五、继承的访问控制

在继承中，访问控制符（如public、protected、private）对属性和方法的可见性起着至关重要的作用。以下是对不同访问控制符的解释：

public: 公有成员可以被任何类访问，包括子类。
protected: 受保护成员只能在同一个包内的类或任何子类中访问。
private: 私有成员只能在声明它的类内部访问，不能在子类中直接访问。

以下是一个示例：

class Parent {
    public String publicField = "Public";
    protected String protectedField = "Protected";
    private String privateField = "Private";
    public void display() {
        System.out.println("Public Field: " + publicField);
        System.out.println("Protected Field: " + protectedField);
        System.out.println("Private Field: " + privateField);
    }
}
class Child extends Parent {
    public void displayChild() {
        System.out.println("Public Field: " + publicField);
        System.out.println("Protected Field: " + protectedField);
        // System.out.println("Private Field: " + privateField); // This will cause a compile-time error
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.displayChild();
    }
}

在上述代码中，子类Child可以访问父类Parent中的公有和受保护成员，但不能直接访问私有成员。

六、使用接口和抽象类

有时候，继承父类属性和方法时，使用接口和抽象类会更灵活和有效。接口定义了类必须实现的方法，而抽象类可以包含具体的方法实现和抽象方法。以下是一个示例：

使用接口

interface Animal {
    void makeSound();
}
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
    }
}

使用抽象类

abstract class Animal {
    public abstract void makeSound();
    public void sleep() {
        System.out.println("Zzz");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

在上述代码中，Dog类实现了接口Animal并继承了抽象类Animal，从而实现了多态性。

七、实例化父类和子类

在Java中，可以实例化子类并通过子类对象访问继承自父类的属性和方法。以下是一个示例：

class Parent {
    public String name;
    public Parent(String name) {
        this.name = name;
    }
    public void display() {
        System.out.println("Parent Name: " + name);
    }
}
class Child extends Parent {
    public int age;
    public Child(String name, int age) {
        super(name);
        this.age = age;
    }
    @Override
    public void display() {
        super.display();
        System.out.println("Child Age: " + age);
    }
}
public class Main {
    public static void main(String[] args) {
        Parent parent = new Parent("John Sr.");
        parent.display();
        Child child = new Child("John Jr.", 25);
        child.display();
    }
}

在上述代码中，Parent类和Child类都被实例化，并且可以通过Child类对象访问父类的display方法。

八、总结

通过上述示例和解释，可以看到Java中子类继承父类属性的多种方式。使用extends关键字、调用父类构造方法、通过super关键字访问父类方法和属性、重写父类方法、理解继承的访问控制、使用接口和抽象类、实例化父类和子类，这些都是实现继承的重要手段。掌握这些方法将帮助你更好地理解和应用面向对象编程的继承机制。