java子类中如何调用父类属性

在Java中，子类可以通过继承来调用父类的属性。 具体方法包括：使用super关键字访问父类属性、直接访问继承的公共属性、通过父类的公共方法访问私有属性。其中，使用super关键字是最直接的方式。

一、使用super关键字访问父类属性

在Java中，super关键字用于调用父类的构造方法和属性。当子类需要调用父类的属性时，尤其是当属性被覆写时，可以使用super来明确指示调用父类的版本。例如：

class Parent {
    public String name = "Parent";
}
class Child extends Parent {
    public String name = "Child";
    public void printName() {
        System.out.println(super.name); // 输出 "Parent"
        System.out.println(this.name);  // 输出 "Child"
    }
}

在上面的例子中，super.name用于调用父类中的name属性，而this.name调用子类中的name属性。

二、直接访问继承的公共属性

如果子类继承了父类的公共属性，那么在子类中可以直接访问这些属性而不需要额外的关键字。例如：

class Parent {
    public String name = "Parent";
}
class Child extends Parent {
    public void printName() {
        System.out.println(name); // 直接访问父类的name属性
    }
}

在这个例子中，name属性在子类中可以直接访问，因为它是公共属性。

三、通过父类的公共方法访问私有属性

有时候，父类的属性可能是私有的，这意味着它们不能直接被子类访问。在这种情况下，可以通过父类的公共方法来访问这些私有属性。例如：

class Parent {
    private String name = "Parent";
    public String getName() {
        return name;
    }
}
class Child extends Parent {
    public void printName() {
        System.out.println(getName()); // 通过父类的公共方法访问私有属性
    }
}

在这个例子中，getName()方法返回父类的私有属性name，子类通过调用getName()方法来访问这个私有属性。

四、继承与多态

Java中的继承和多态是两个重要的概念，它们使得代码更加灵活和可维护。通过继承，子类可以重用父类的代码，而通过多态，子类可以提供自己独特的实现。

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

在这个例子中，Child类重写了Parent类的display方法。由于多态性，obj.display()将调用子类的display方法。

五、父类构造函数的调用

在子类构造函数中，可以使用super()来调用父类的构造函数。这在需要初始化父类的属性时特别有用。

class Parent {
    public Parent(String name) {
        System.out.println("Parent constructor: " + name);
    }
}
class Child extends Parent {
    public Child(String name) {
        super(name); // 调用父类的构造函数
        System.out.println("Child constructor: " + name);
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child("Test");
    }
}

输出将是：

Parent constructor: Test Child constructor: Test

在这个例子中，子类的构造函数调用了父类的构造函数，并传递了参数。

六、访问父类静态属性和方法

静态属性和方法属于类本身，而不是类的实例。可以通过类名直接访问父类的静态属性和方法。

class Parent {
    public static String staticName = "ParentStatic";
    public static void staticMethod() {
        System.out.println("Parent static method");
    }
}
class Child extends Parent {
    public void printStatic() {
        System.out.println(Parent.staticName); // 访问父类的静态属性
        Parent.staticMethod(); // 访问父类的静态方法
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.printStatic();
    }
}

在这个例子中，子类通过父类的类名访问其静态属性和方法。

七、父类的受保护属性和方法

protected修饰符允许子类访问父类的属性和方法，但这些属性和方法不能被其他包中的非子类访问。

class Parent {
    protected String protectedName = "Protected Parent";
    protected void protectedMethod() {
        System.out.println("Protected method in Parent");
    }
}
class Child extends Parent {
    public void accessProtected() {
        System.out.println(protectedName); // 访问父类的受保护属性
        protectedMethod(); // 访问父类的受保护方法
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.accessProtected();
    }
}

在这个例子中，子类可以访问父类的受保护属性和方法。

八、父类引用和子类对象

父类引用可以指向子类对象。这是多态的基础，使得代码更加灵活。

class Parent {
    public void method() {
        System.out.println("Method in Parent");
    }
}
class Child extends Parent {
    @Override
    public void method() {
        System.out.println("Method in Child");
    }
}
public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        parent.method(); // 输出 "Method in Child"
    }
}

在这个例子中，尽管引用类型是Parent，但实际对象是Child，因此调用的是子类的method方法。

九、抽象类和接口

抽象类和接口是Java中实现多态和继承的重要工具。抽象类可以包含具体方法和抽象方法，而接口只能包含抽象方法（Java 8之后接口可以包含默认方法和静态方法）。

abstract class Parent {
    public abstract void abstractMethod();
    public void concreteMethod() {
        System.out.println("Concrete method in Parent");
    }
}
class Child extends Parent {
    @Override
    public void abstractMethod() {
        System.out.println("Abstract method implemented in Child");
    }
}
interface InterfaceExample {
    void interfaceMethod();
}
class ChildWithInterface implements InterfaceExample {
    @Override
    public void interfaceMethod() {
        System.out.println("Interface method implemented in ChildWithInterface");
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.abstractMethod();
        child.concreteMethod();
        ChildWithInterface childWithInterface = new ChildWithInterface();
        childWithInterface.interfaceMethod();
    }
}

在这个例子中，Child类实现了抽象类Parent中的抽象方法，ChildWithInterface类实现了接口InterfaceExample中的方法。

十、总结

在Java中，子类调用父类属性的方式有很多，具体取决于属性的访问修饰符和子类的需求。通过使用super关键字、直接访问继承的公共属性、通过父类的公共方法访问私有属性等方式，子类可以灵活地调用和使用父类的属性。同时，Java的继承和多态机制使得代码更加灵活和可维护。理解并正确使用这些机制，将有助于编写高效且易于维护的Java应用程序。