假设父类 A 中某成员 a 的访问特性为 protected，从父类 A public 派生出子类 B， 则在子类 B 中对成员 a 的访问特性为

在子类 B 中，成员 a 的访问特性仍然是 protected，因为在公有派生中，派生类继承了基类中所有的成员，包括访问特性。protected 成员可以被派生类中的成员函数和友元函数访问，但不能被派生类对象直接访问。因此，在子类 B 中，成员 a 可以被子类 B 的成员函数和友元函数访问，但不能被子类 B 的对象直接访问。

相关问题

Java、设计父类和子类。 自行设计一父类。多个子类扩展该父类，父类有私有的域和方法、子类覆盖父类的方法， 代码有差异性。同时子类中设计各自独有的方法设计protected的域和方法，在子类中访问。子

Java中的类继承是一种创建新类的方式，它允许子类（也称为派生类或衍生体）从已存在的父类（也称为超类或基类）继承属性和行为。在设计过程中，首先我们创建一个父类，通常包含一些通用的属性（域，也称为成员变量）和方法，这些都是公共部分，所有子类都能访问。

例如，我们可以设计一个`Animal`父类：

public class Animal {
    private String name; // 私有域，防止直接访问

    public Animal(String name) {
        this.name = name;
    }

    // 公共方法
    public void eat() {
        System.out.println(name + " is eating.");
    }

    protected void sleep() { // 保护级方法，子类可以访问
        System.out.println(name + " is sleeping.");
    }
}

然后我们可以有两个子类，如`Dog`和`Cat`，它们分别从`Animal`派生并覆盖或扩展父类的行为：

public class Dog extends Animal {
    // 子类特有的域和方法
    private int age;

    public Dog(String name, int age) {
        super(name); // 调用父类构造函数
        this.age = age;
    }

    @Override
    public void eat() {
        System.out.println(name + " is happily eating.");
    }

    // 狗特有的行为
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Cat extends Animal {
    // 猫特有的域和方法
    private boolean isGrumpy;

    public Cat(String name, boolean isGrumpy) {
        super(name);
        this.isGrumpy = isGrumpy;
    }

    @Override
    public void sleep() {
        if (isGrumpy) {
            System.out.println(name + " sleeps grumpily.");
        } else {
            System.out.println(name + " sleeps peacefully.");
        }
    }

    // 猫特有的行为
    public void purr() {
        System.out.println(name + " is purring.");
    }
}

、设计父类和子类。 自行设计一父类。多个子类扩展该父类，父类有私有的域和方法、子类覆盖父类的方法， 代码有差异性。同时子类中设计各自独有的方法设计protected的域和方法，在子类中访问。子类重写toString()方法和equals()方法

在面向对象编程中，设计父类（也称为超类或基类）是为了提供一种通用的行为模板，而子类（派生类）则是为了扩展这种模板并添加特定于自身功能。下面是一个简单的例子：

// 设计父类 Animal
public class Animal {
    // 私有域（数据成员）
    private String name;
    
    // 公共构造函数和方法
    public Animal(String name) {
        this.name = name;
    }
    
    // 父类方法
    protected void eat() {
        System.out.println(name + " is eating.");
    }

    // 定义公共方法，用于展示信息
    public String toString() {
        return "Animal: " + name;
    }
}

// 子类Cat和Dog继承自Animal
public class Cat extends Animal {
    // 子类特有的保护域
    protected int lives;

    // 重写父类eat方法，增加猫吃东西的特点
    @Override
    protected void eat() {
        System.out.println(name + " is eating fish.");
    }

    // 子类特有的方法
    public void meow() {
        System.out.println(name + " says 'Meow'.");
    }

    @Override
    public String toString() {
        return super.toString() + ", Lives: " + lives;
    }
}

public class Dog extends Animal {
    // 子类特有的保护域
    protected String breed;

    // 重写父类eat方法，增加狗吃东西的特点
    @Override
    protected void eat() {
        System.out.println(name + " is eating dog food.");
    }

    // 子类特有的方法
    public void bark() {
        System.out.println(name + " says 'Woof woof'.");
    }

    @Override
    public String toString() {
        return super.toString() + ", Breed: " + breed;
    }
}

// 使用示例
public static void main(String[] args) {
    Animal myCat = new Cat("Mimi", 9);
    Animal myDog = new Dog("Max", "German Shepherd");

    System.out.println(myCat); // 输出: Animal: Mimi, Lives: 9
    myCat.eat(); // 输出: Mimi is eating fish.
    myCat.meow(); // 输出: Mimi says 'Meow'.

    System.out.println(myDog); // 输出: Animal: Max, Breed: German Shepherd
    myDog.eat(); // 输出: Max is eating dog food.
    myDog.bark(); // 输出: Max says 'Woof woof'.
}