JavaEE: lesson1: 继承

JavaEE: lesson 1: 继承

继承: （inheritance）是面向对象软件技术当中的一个概念。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
如果某类B“继承”另某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）”。

1.继承的概念

在一个已知类A的基础上,创建新类B的过程,称之为继承
    
这里类A,称为父类,基类,超类,英文名SuperClass
这里类B,称为子类,派生类,英文名SubClass        

2.1 继承的格式

格式:
	public class 父类{
     	//成员变量
        //成员方法
    }

	public class 子类 extends 父类{
        子类中就自动继承了父类中的成员变量和成员方法
        子类也可以添加自己的成员变量和成员方法    
    }

2.2 继承的案例

父类:人类
    public class Human {
        //人类的共同成员变量和成员方法
        int age;
        String name;
        public void eat(){
            System.out.println("我吃蝙蝠...");
        }
        public void sleep(){
            System.out.println("我听课睡着了...");
        }
    }
学生类:
    public class Student extends Human{
    }
老师类:
    public class Teacher extends Human {
        //薪水
        double salary;
        //教书
        public void teach(){
            System.out.println("#$%&*($%^*()%&*...");
        }
    }

班主任类:
	public class BanZhuRen extends Human{
        //薪水
        double salary;
        //管理
        public void manager(){
            System.out.println("开播了,赶紧起床~~~~");
        }
    }
测试类
    public class TestDemo {
        public static void main(String[] args) {
            //1.测试Student类
            Student s1 = new Student();
            System.out.println(s1.age);
            System.out.println(s1.name);
            s1.eat();
            s1.sleep();
            //2.测试Teacher类
            Teacher t1 = new Teacher();
            System.out.println(t1.age);
            System.out.println(t1.salary);
            t1.eat();
            t1.teach();
            //3.班主任类...自己写完
        }
    }

• 继承好处总结

  a.提高代码的复用性
  b.类与类之间有了关系,为以后学的"多态"提供了前提   

2.4 子类不能继承的内容

a.父类的构造方法子类无法继承!! (因为构造方法和类名是一样的)
b.父类的私有成员,子类可以继承但是不能直接使用!!!(间接使用)

父类:
	public class Animal {
        private int age;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Animal() {
        }
        public Animal(int age) {
            this.age = age;
        }
	}

子类:
	public class Dog extends Animal {
        //构造方法无法继承
        //私有成员能继承,但是子类无法直接访问
    }

测试类:
	public class TestDog {
    public static void main(String[] args) {
        //1.创建Dog对象
        Dog d = new Dog();
        //2.构造方法无法继承
        //Dog d1 = new Dog(10); //报错!!
        //3.私有成员可以继承,但是无法直接访问
        //d.age; //错误,无法直接访问
        //比如:
        //古代皇帝,皇帝驾崩了,太子继位,
        //皇帝江山属于太子,但是皇帝妃子,太子也继承了叫额娘,但是不能用!!
        //4.私有成员我们可以间接访问
        //我们通过 get和set方法,间接访问私有成员
        d.setAge(10);
        int age = d.getAge();
        System.out.println("获取到age:"+age);
    }
}
   

2.5 继承后的特点——成员变量

a.当子父类的成员变量不同名时,访问成员变量时没有歧义,写哪个变量名就是访问哪个变量
b.当子父类的成员变量同名时,在子类中会根据就近原则,优先访问子类自己的那个成员变量
c.如果我就想访问父类的成员变量,能否做到???
    	可以,在子类的方法中,使用super.变量名,就会访问父类中那个成员变量!
    
//父类
public class Fu {
//    int numFu = 10;
    int num = 10;
}
    
//子类
public class Zi extends Fu{
//    int numZi = 99;
    int num = 99;
    //展示
    public void show() {
        //子父类成员变量不同名
//        System.out.println(numZi); // 99
//        System.out.println(numFu); // 10
        //子父类成员变量同名
        //就近原则,优先访问子类自己的成员变量
        System.out.println(num); // 99

        //如果就想访问父类的num能否做到??
        //使用Java提供的另外一个关键字
        System.out.println(super.num); //10
    }
}  

public class TestDemo {
    public static void main(String[] args) {
        //1.创建Zi对象
        Zi zz = new Zi();
        //2.调用方法
        zz.show();
    }
}

2.6 继承后的特点——成员方法[重点]

a.当子父类的成员方法不同名时,调用成员方法时没有歧义,写哪个方法名就是调用哪个方法
b.当子父类的成员方法同名时,使用子类对象调用该方法,根据就近原则,优先调用子类自己的那个成员方法  
c.如果我就想通过子类对象,调用父类中的那个同名方法,能做到吗???
    	不能做到!!
    	但是可以在子类的方法中,使用super.方法名()调用父类那个同名方法!!!
    
/**
 * 父类
 */
public class Fu {
//    public void showFu() {
//        System.out.println("Fu类的show....");
//    }

    public void show() {
        System.out.println("Fu类的show....");
    }
}

/**
 * 子类
 */
public class Zi extends Fu {

//    public void showZi(){
//        System.out.println("Zi类的show...");
//    }

    public void show(){
        //在子类中可以使用super
        System.out.println("Zi类的show...");
        super.show();
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //1.创建子类对象
        Zi zz = new Zi();
        //2.调用方法
        //子父类成员方法不同名
//        zz.showZi(); //Zi类的show...
//        zz.showFu(); // Fu类的show....
        //子父类成员方法同名
        //就近原则,优先子类自己的show方法
        zz.show(); // Zi类的show...
        //无法做到直接通过子类对象,super去调用父类的同名方法
        //zz.super.show(); //报错!!!因为在测试类使用super,并不是Fu类,而是指测试类的父类
        //可以在子类的show方法中,使用super.show()调用父类的同名方法
        //记住: super关键字只能在子类内部使用
    }
}

2.7 重写的概念和应用

方法的重载(overload):
	在同一个类中,出现了方法名一样,但是参数列表(参数个数|参数类型|参数顺序)不一样的各种方法,称为方法的重载
方法的重写(override):
	在继承关系中,子类中出现了一个和父类除了方法体,其他一模一样的方法,称为方法的重写     
  
方法重写的具体应用:        
	子类继承父类时,会继承父类的成员方法,那么当子类发现继承过来的方法功能不足或者不适用时,子类就可以重写该方法,重新实现自己需要的方法体即可  

/**
 * 动物类
 */
public class Animal {

    public void eat(){
        System.out.println("动物在吃");
    }

    public void sleep(){
        System.out.println("动物在睡");
    }
}

/**
 * 狗类
 */
public class Dog extends Animal{
    //当子类继承父类的方法后,发现父类的方法功能不足或者不适用,我们可以重写
    public void eat(){
        System.out.println("狗狗舔着吃...");
    }

    public void sleep(){
        System.out.println("狗狗趴着睡...");
    }
}      

2.8 @Override注解

@Xxxx 这种东西,我们称为注解,英文名Annotation
@Override  此注解叫做方法重写注解,
			主要作用就是检查重写的方法是否格式正确(和父类的除了方法体一模一样)  

/**
 * 动物类
 */
public class Animal {

    public void eat(){
        System.out.println("动物在吃");
    }

    public void sleep(){
        System.out.println("动物在睡");
    }
}

/**
 * 狗类
 */
public class Dog extends Animal{
    //当子类继承父类的方法后,发现父类的方法功能不足或者不适用,我们可以重写
    @Override //加上此注解,可以帮助我们检测eat方法重写的是否正确
    public void eat(){
        System.out.println("狗狗舔着吃...");
    }
    @Override //加上此注解,可以帮助我们检测eat方法重写的是否正确
    public void sleep(){
        System.out.println("狗狗趴着睡...");
    }
}
                

2.9 方法重写的注意事项

a.方法重写是发生在子父类之间的关系
b.子类方法重写父类方法，必须要保证权限大于等于父类权限(一般来说,父类方法写啥权限,子类也写啥权限)
    		Java中有四大权限,从大到小依次为:
			public protected 不写(默认|default) private
c.方法重写,除了方法体其他的都要和父类一模一样(虽然权限可以不一样,但是一般我们也写一样的权限)            

2.10 继承后的特点——构造方法

• 构造方法特点介绍

  a.子类能否继承父类的构造方法??
      	子类是无法继承父类的构造方法   
  b.在子类的"任何构造方法"的"第一行",都有默认一句代码"super()",代表调用父类的无参构造    

• 构造方法案例演示

  /**
   * 父类
   */
  public class Person {
      int age;
      String name;
  
      public Person() {
          System.out.println("Person的无参构造...");
      }
  }
  
  
  /**
   * 子类
   */
  public class Worker extends Person {
      //工资
      double salary;
  
      //构造方法
      public Worker(){
          //默认有一句代码 super();
          System.out.println("Worker的构造方法");
      }
  
      public Worker(double salary){
          //默认有一句代码 super();
          this.salary = salary;
          System.out.println("Worker的salary构造方法");
      }
  
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          //1.创建Worker对象
  //        Worker w = new Worker(); // 调用子类无参构造,子类无参构造中调用父类的无参构造
          Worker w = new Worker(3000); // 调用子类有参构造,子类有参构造中调用父类的无参构造
      }
  }

• 构造方法总结

  a.子类的任何构造,第一行都会调用父类的无参构造
  b.子类的构造方法第一行,super是默认存在的,可以省略不写,但是不写不代表没有!!!    
  

2.11 super(参数)和this(参数)

• 案例引入

  /**
   * 父类
   */
  public class Person {
      int age;
      String name;
  
      public Person() {
          System.out.println("Person的无参构造...");
      }
  
      public Person(int age, String name) {
          this.age = age;
          this.name = name;
          System.out.println("Person有参构造");
      }
  }
  
  /**
   * 子类
   */
  public class Worker extends Person {
      //工资
      double salary;
  
      //构造方法
      public Worker(){
          //默认有一句代码 super();
          System.out.println("Worker的构造方法");
      }
  
      public Worker(double salary){
          //默认有一句代码 super();
          this.salary = salary;
          System.out.println("Worker的salary构造方法");
      }
  
      //子类的构造中默认第一行调用父类无参构造
      //但是我们可以手动修改super()代码,让他调用有参构造
      public Worker(int age,String name,double salary){
          //调用父类的有参构造
          super(age,name);
          this.salary = salary;
      }
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          //1.创建Worker对象
          Worker w = new Worker(20,"小王吧",4000);
          //2.打印对象中属性值
          System.out.println(w.name);
          System.out.println(w.age);
          System.out.println(w.salary);
      }
  }
  

• super(…)用法演示

  super() 代表调用父类的无参构造,默认的super(参数) 代表调用父类的
  有参构造,具体调用哪个有参构造根据参数来决定   
  

• super案例图解

• this(…)用法演示

  this(参数):
  在本类的构造方法中调用本类的其他构造     
  public class Dog {
      int age;
      String name;
      public Dog() {
          //在本类的构造方法中
          this(10,"来福");
          //调用本类的另外一个构造
      }
  	public Dog(int age, String name) {
          this.age = age;
          this.name = name;
  	 }
  }
  注意: this(参数)也必须写在构造方法的第一行,
  所以this(参数)和super(参数)他们只能出现一个.
  

• 小结

a.子类的构造方法中默认有一句super()调用父类无参构造,我们可以手动改
super(参数)调用父类的有参构造,具体是哪个有参构造,由参数决定
b.super(...)和this(...) 必须在第一行,所有不能同时出现
c.super(..)和this(..)调用父类的构造和子类自己的其他构造,
		具体哪个构造由参数决定
d.super(..) 调用父类的有参构造,初始化父类继承的成员变量
e.this(..) 调用子类的其他构造方法