java-面向对象-继承

package javamxdx.fz.dt.jc;
/** 
 *  超类，基类（俗称父类）
 */
public class Car {

    String color;//定义三个属性
    float price;
    private String brand;//这个来用private修饰，一会看子类能不能继承
    //当然是继承不了的....
  
    public Car() {//构造方法
        System.out.println("父类构造方法.......");
    }
    
    public Car(String color, float price) {//构造方法重载
        super();
        this.color = color;
        this.price = price;
        System.out.println(color+"-"+price);
    }

    public void run() {//普通没有返回值的方法
        System.out.println("跑..........");
    }
    public void stop() {
        System.out.println("停..........");
    }    
}

package javamxdx.fz.dt.jc;
/**
 * 子类，继承超类（父类）car
 *java 单一继承，一次只能继承一个类
 */
public class Bmw extends Car{
    //extends 继承关系--Bmw（子类）--->car（父类）

    @Override  //方法重写
    /**
    方法重写，子类可以重写父类的方法   重写必须满足继承关系
    特点：方法名相同，参数、类型、返回值都相同，方法体可不同
    (切记：构造方法不能被重写，只能被重载)
    */
    public void run() {//方法重写
        System.out.println("run......---");
    }
    @Override
    public void stop() {//方法重写
    System.out.println(super.color);//super可以调用父类的属性
                       //能不能调用private修饰的？不能！！
    System.out.println("stop......---");
        }
//注意以上两个普通方法重写，这两个方法和父类一模一样，只是方法体不一样
//而子类重写了父类的方法以后就会覆盖父类的方法

    //注意这个是子类的构造方法
    public Bmw() {//先执行父类的构造方法
        System.out.println("bmw.........");
    }
    //子类继承父类是先加载父类，后加载子类
    //所以会先执行父类的构造方法，再执行子类的构造方法
    //意思是父类和子类的构造方法都会执行打印，只是有先后顺序
  
    /**
     * java中所有类都继承Object类（Object是所有类的祖先）
     */
    
    String shape;//定义一个属性
    
    public Bmw(String shape) {//重载子类构造方法，写了一个参数
      
         super();//super 就是执行父类的构造方法 ，不写也默认
      
         //super("黑色", 9.9f);//super必须放在构造方法的第一行
         //这行super后面还有参数，是因为继承了父类带参数的构造方法
      
         //super.run();//直接调用父类的普通方法
   
        System.out.println(shape+"..........");
        //this------->new Bmw()当前对象
        //super------>new Car() 父类对象
    }

    public static void main(String[] args) {
        Bmw a=new Bmw();//创建一个子类对象
        a.run();//调用子类重写父类的方法
        a.stop();//调用子类重写父类方法
    }
}

package javamxdx.fz.dt.jc;
//2021-10-28
public class School {

    /*2.升级学校管理系统，教师分为java教师和.net教师，授课行为不一样。*/
    String java;//
    String net;
    
    public School() {//父类构造方法，如果写了带参的构造方法，这个就必须写
        // TODO Auto-generated constructor stub
    }

    public School(String java, String net) {//父类带参是的构造方法
        super();
        this.java = java;
        this.net = net;
        System.out.println(java+"老师教学java编程语言知识");
        System.out.println(net+"老师教学计算机网络知识");
    }
}

package javamxdx.fz.dt.jc;

public class SchoolTest extends School{

    public SchoolTest() {
        super("java", "net");//调用父类带参的构造方法给赋值
    }
    public static void main(String[] args) {
        SchoolTest b=new SchoolTest();
    }
}

package javamxdx.fz.dt.jc;

public class Animal {
    /**
     * 基类，超类
     */
    public void eat() {
        System.out.println("动物吃......");
    }
    public void sleep() {
        System.out.println("动物都会睡觉");
    }

  //这里我们只写两个方法
  
}

package javamxdx.fz.dt.jc;

public class Tiger extends Animal{
    
    public Tiger() {
        // TODO Auto-generated constructor stub
    }

    @Override
    public void eat() {//重写父类方法
        System.out.println("老虎吃肉");
    }
}

package javamxdx.fz.dt.jc;

public class Rabbit extends Animal{

    public Rabbit() {
        // TODO Auto-generated constructor stub
    }
    
    //子类重写父类的eat方法，子类将覆盖父类的方法
    @Override
    public void eat() {//重写父类方法
        System.out.println("兔子吃草");
    }
}

package javamxdx.fz.dt.jc;

public class AnimalTest{

    public void test(Animal a) {//继承与多态的混合
      //注意这里的参数写父类名称，变量就是子类名称
        a.eat();
        a.sleep();
    }
    
    public static void main(String[] args) {
        /*Rabbit t=new Rabbit();
        t.eat();
        t.sleep();
        Tiger r=new Tiger();
        r.eat();
        r.sleep();*/
        
        /*Animal t=new Tiger();//子类对父类引用
        t.eat();
        t.sleep();*/
      
        AnimalTest at=new AnimalTest();
        at.test(new Tiger());//本类对象调用方法new 子类对象
        at.test(new Rabbit());//new对象简写
        //这种new看不懂的可以看上面我注释掉的那些
    }
}