面向对象3

• 继承：是从已有的类中派生出新的类，新的类从已有的类中得到属性和行为，并扩展新的能力。

• java中继承用extends关键字来表示继承关系。

• java不支持多继承，一个类只能继承一个父类

• 继承父类之后的子类可以调用父类的任何非私有的属性和方法

• [访问权限修饰符] [修饰符] 子类名 extends 父类名{子类体}

//public class Animal extends objects{
       public class Animal {    
      //成员变量    
         private String name;    
         private  int age;    
       //构造方法    
          public Animal(){       
           super();       
              System.out.println("Animal类中的无参构造方法");   
                }    
                public Animal(String name){        
                    super();      
                    this.name = name;     
                   System.out.println("Animal类中的有参构造方法");  
                              }   
                //成员方法,是类的功能   
                      public void eat(){       
                        System.out.println("动物吃东西");    }  
             //为私有属性对外提供的操作入口    
               public String getName(){     
                    return name;    }   
           public void setName(String name){     
               this.name = name;    }   
                 public int getAge(){       
               return age; 
                    }   
             public void setAge(int age){     
             this.age = age;    }}
​
public class Cat extends Animal{
​
    public Cat(){
        System.out.println("猫类中的无参构造方法");
    }
}
​

public class Dog extends Animal{
    private String color;
​
    public Dog(){
        super();
        System.out.println("狗类中的无参构造方法");
    }
​
    public Dog(String name){
        super(name);
        System.out.println("狗类中的有参构造方法");
    }
​
    public void play(){
        System.out.println("狗会玩");
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}
​
public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //调用父类功能
        dog.setName("二狗");
        dog.setAge(3);
        dog.eat();
​
        //调用子类特有的功能
        dog.setColor("金色");
        dog.play();
​
        XiaoTianQuan xtq = new XiaoTianQuan();
        xtq.setName("哮天犬");
        xtq.setAge(5000);
        xtq.eat();
​
        xtq.setColor("黑色");
        xtq.play();
​
        xtq.fly();
​
        xtq.hashCode();//调用的是Object类中的方法
​
    Cat cat = new Cat();
​
    }
}

• Dog dog = new Dog();调用了父类的无参构造方法

• Cat Dog继承了Animal，是Animal的派生类(子类)，

Animal是Cat Dog 的父类(基类)

new XiaoTianQuan();
Animal类中的无参构造方法
狗类中的无参构造方法
哮天犬类中的无参构造方法
在创建子类对象后,调用构造方法时,从上向下的调用,先初始化父类信息
使用super()在子类构造方法的第一行默认执行,调用父类无参的构造方法

public class XiaoTianQuan extends Dog{
​
​
    public XiaoTianQuan(){
        super();//表示调用父类中的无参构造,默认存储在,必须放在第一行
        System.out.println("哮天犬中的无参构造方法");
    }
​
    public XiaoTianQuan(String name){
        super(name);
        System.out.println("哮天犬中的有参构造方法");
    }
​
    
    @Override
     public void eat(){
         System.out.println("神犬坐着吃饭");
     }
​
     public void play(){
         System.out.println("神犬飞着玩");
        super.eat();
}
​
    public void fly(){
        System.out.println("哮天犬会飞");
        //super.play();  //误区：super表示父类对象
    }
​
​
}
​
public class Test2 {    
public static void main(String[] args) {     
XiaoTianQuan xtq2 = new XiaoTianQuan("哮天犬二代");        System.out.println(xtq2.getName());    
}}

联系最上面的代码Animal Dog 易知XiaoTianQuan继承了Dog 而Dog继承了Animal

XiaoTianQuan xtq2 = new XiaoTianQuan("哮天犬二代");

调用了父类的有参构造方法

• 使用super关键字访问父类成员

  • 用super.成员变量名访问父类的成员变量名

  • 用super.方法名(参数列表)访问父类的方法

  • 用super.构造方法(参数列表)来访问父类的构造方法

误区：不要把super误以为是父类的对象，在创建子类对象的时候，不会创建父类对象

只会将父类中的信息加载到子类对象中存储.

• 应用场景;

  当父类的方法不能满足子类的需求时，需要对方法进行重写(Override)

• 在子类中可以根据子类所需要的来对父类的方法进行重写

• 方法重写的规则：

  • 方法名形同，参数列表相同

  • 返回值的类型需要相同

  • 访问权限 不能小于父类的权限

注意：构造方法,静态方法不能重写,成员变量不存在重写