public class A {// extend01包中
    private int a;
    int b;
    protected int c;
    public int d;
}
// extend01包中
// 同一个包中的子类
class B extends A{
    void method(){
        // super.a=10;// 编译报错，父类private成员在相同包子类中不可见
        super.b=10;
        super.c=20;
        super.d=30;
    }
}
// extend02包中
// 不同包中的子类
class C extends A{
void method(){
    //super.b=20;// 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
    super.c=30;
    super.d=40;
}
}
// extend02包中
// 不同包中的类
public class test6 {
    public static void main(String[] args) {
        C c = new C();
        //c.c=50;// 父类中protected成员在不同包其他类中不能直接访问
        c.d=66;
    }
}

final int a=10;
  //  a=20;//编译出错

final class Q{
}
class W extends Q{// 编译出错
}

class A{
public final void func(){
    System.out.println("66666");
}
}
class B extends A{
    //public void func(){}编译出错
}

// 轮胎类
class Tire{} // 发动机类
class Engine{} // 车载系统类
class VehicleSystem{}
class Car{
private Tire tire; // 可以复用轮胎中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private VehicleSystem vs; // 可以复用车载系统中的属性和方法
} // 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

class per{
    String name;
    int age;
    public per(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"吃饭");
    }
}
class stu extends per{
    public stu(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃学生餐");
    }
}
class tea extends per{
    public tea(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃教师餐");
    }
}
public class test8 {
    // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
    // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
    // 注意：此处的形参类型必须时父类类型才可以
    public static void test(per a) {
        a.eat();
    }
    public static void main(String[] args) {
        stu stu1 = new stu("张三",99);
        tea tea1 = new tea("韩顺平老师",44);
        test(stu1);
        test(tea1);
    }
}

Animal animal = new Cat("狗剩",2);

public class test {
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void func(animal qq){
        qq.eat();
    }
    // 3. 作返回值：返回任意子类对象
    public static animal func1(String ww){
        if("狗".equals(ww)){
            return new animal("狗狗",1);
        }else if("猫".equals(ww)){
            return new animal("猫猫",1);
        }else
            return null;
    }
    public static void main(String[] args) {
animal  a1=new cat("小猪",18);// 1. 直接赋值：子类对象赋值给父类对象
dog  b1=new dog("小六",6);
func(a1);
func(b1);
animal w1=func1("狗");
w1.eat();
w1=func1("猫");
w1.eat();
    }
}
class animal{
    String name;
    int age;
    public animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"吃饭");
    }
}
class cat extends animal{
    public cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name+"吃鱼");
    }
}
class dog extends animal{
    public dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name+"吃骨头");
    }
}

// 编译失败，编译时编译器将a当成Animal对象处理
        // 向上转型
        // 程序可以通过编程，但运行时抛出异常---因为：a实际指向的是狗
        // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        animal a=new dog("小猪",6);
        cat cat1=new cat("小猫",9);
        cat1=(cat)a;

animal a=new dog("小猪",6);
        if(a instanceof cat){  //显然表达式为false，不能进行转换
        cat cat1=new cat("小猫",9);
        cat1=(cat)a;}