面向对象(三)之继承在此,多态在后

继承,重写,多态,重点往往都是一起跳舞的

一、继承

• 继承:父类和子类
• 子类会具有父类的一些功能,可以提高代码的重用性
• 继承是面向对象语言的一种设计思想,
  • 提高代码的可重复利用性(儿子可以使用父亲)
  • 代码的可扩展性(子类可以有自己的功能)
• 父类(基类)可以把一些共有的属性定义在父类中
• 继承的传递性
  C类从B类继承,B类又从A类继承
  那么C类就具有B类和A类的所有非私有属性和非私有方法
• 当一个类没有写继承,则他会默认继承Object类
• Object是所有类的基类(父类)也叫超类

1. 继承语法extends关键字

• 语法:
  [访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}
• java中一个类只能继承一个类
  • Cat继承Animal
• Cat类是Animal类的子类
• 子类可以扩展自己的功能
• 专业术语
  Cat类是 Animal类的子类, Animal类是Cat类的父类
  Cat类是 Animal类的派生类, Animal类是Cat类的基类

private String name;
    private int age;

    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 void eat(){
        System.out.println("动物吃");
    }

public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("TOM");
        cat.setAge(3);
        System.out.println(cat.getAge()+"   "+cat.getName());
        cat.eat();
        cat.setPinzhong("布偶");
        cat.jiao();
    }

2.关键字supre

• super关键字用途
  • super关键字代表父类的引用，在程序中主要的用途
  • 在子类构造方法中要调用父类的构造方法，需要注意：super语句只 能出现在子类构造方法体的第一行。
    • 用“super.成员变量名”来引用父类成员变量
    • 用“super.方法名（参数列表）”的方式访问父类的方法。
• 与this的区别，this通常指代当前对象，super通常指代父类。

  public Cat(){
        super("哈哈");//如果supre里传入一个参数,则调用Animal中有参的构造方法
            System.out.println("Cat的无参的构造方法");
        }

  /*
    一个类可以
    调用子类构造方法时,先会调用父类Animal的构造方法
    关键字super
    构造方法的第一行,默认使用super来调用父类默认无参构造方法,
     */
    public void feel(){
        System.out.println("Tom会喂杰瑞吃饭");
    }
    public Tom(){
        super();//如果要显示的调用,必须放在构造方法的第一行,先确保分类的调用
        System.out.println("Tom类的无参构造方法");
        super.eat();//可以通过super来调用父类中的方法
    }

3.重写

• 什么时候需要重写:父类的方法不能满足子类的需求
• 方法的重写:当子类中的实现与父类中的不同时,可以在子类中将父类中的方法重写(覆盖/复写)
  • 要求:
    • 子类方法的结构必须与父类相同
    • 子类重写后的访问权限必须大于等于父类的访问权限
• 标签
  • @Override 标签
  • 表示此方法是重写过的

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

//子类:
 @Override
    public  void eat(){
        System.out.println("Tom爱吃小鱼干");
    }

//测试类
  public static void main(String[] args) {
        Tom tom = new Tom(); //这是相当于创建了Tom的对象,Cat的对象,Animal的对象,Object的对象
        tom.eat();
    }

4.继承的细节

• 继承中的构造方法
  在创建一个子类的对象同时也创建父类的对象

• 一个类可以
  调用子类构造方法时,先会调用父类Animal的构造方法

5.总代码如下

• Animal是父类

public class Animal {
    int x = 10;
    static void y(){
        System.out.println("aaaa");
    }
    /*
    继承:父类和子类
    子类会具有父类的一些功能,可以提高代码的重用性
    继承是面向对象语言的一种设计思想,
    提高代码的可重复利用性(儿子可以使用父亲)
    代码的可扩展性(子类可以有自己的功能)
     */
    /*
    父类(基类)可以把一些共有的属性定义在父类中
    当一个类没有写,会默认继承Object
    Object是所有类的基类(父类)也叫超类
     */
    private String name;
    private int age;

    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 void eat(){
        System.out.println("动物吃");
    }
    public Animal(){
        System.out.println("Animal的无参构造方法");
    }
    public Animal(String name){
        this.name = name;
        System.out.println(name);
    }
    static void f(){
        System.out.println("大哥");
    }
}

• Cat是Animal的子类

public class Cat extends Animal {
    //子类可以扩展自己的功能
    private String pinzhong;
    public void setPinzhong(String pinzhong){
        this.pinzhong = pinzhong;
    }
    public String getPinzhong(){
        return pinzhong;
    }
    public void jiao() {
        System.out.println("喵喵喵");
        }
        public Cat(){
        super("哈哈");//如果supre里传入一个参数,则调用Animal中有参的构造方法
            System.out.println("Cat的无参的构造方法");
        }

    }

• Tom是Cat的子类

public class Tom extends Cat{
   
    public void feel(){
        System.out.println("Tom会喂杰瑞吃饭");
    }
    public Tom(){
        super();//如果要显示的调用,必须放在构造方法的第一行,先确保分类的调用
        System.out.println("Tom类的无参构造方法");
        super.eat();//可以通过super来调用父类中的方法
    }
    
    @Override
    public  void eat(){
        System.out.println("Tom爱吃小鱼干");
    }
}

• TomNext是测试类

public class TomNext {
    /*继承中的构造方法
      在创建一个子类的对象同时也创建父类的对象
     */
    public static void main(String[] args) {
        Tom tom = new Tom(); //这是相当于创建了Tom的对象,Cat的对象,Animal的对象,Object的对象
        tom.eat();

    }
}

二、关系

1.继承关系

• 一个类只能由一个直接父类

2.关联关系

• 关联关系:对象与对象直接的连接
• 表示有"has a" 什么什么 有 什么什么

public class People {
    /*
    表示有"has a" 什么什么  有   什么什么
     */
    private String name;
    private int age;
    private Phone phone;//单项关联 一对一   人有一部电话
    private Phone[] phones;//单项关联 一对多
    private List Phoness;//
   
}

3.依赖关系

• 依赖关系"use a"
• 关联中某个方法使用到了另一个类

public class People {
    /*
    依赖关系"use a"
    关联中某个方法使用到了另一个类
     */
    public void feed(Cat cat){
        cat.eat();
    }
}

三、多态

1.什么是多态

• 多态:同一种事物,在不同时刻的不同的状态
• 多态的条件:
  • 要有继承
  • 要有方法重写
  • 父类的引用 指向 子类对象

注

 Animal tom = new Tom();//多态
       DuoTai a = new DuoTai();//编译看左边,运行看右边

• 多态运行时,成员变量看左边
• 多态运行时,静态调用也看左边

2.多态的优点

• 在上述代码中我们在创建一个狗对象
  • 重写父类里面的方法动物吃

public class Dog extends Animal {
    int x = 10;
    static void y(){
        System.out.println("bbbbb");
    }
    @Override
    public void eat(){
        System.out.println("狗哥吃");
    }
}

• 创建一个DouTai的类
  • 下述是不用多态写的,要实现喂动物
  • 那是不是要喂几个动物就要多写几个方法来调用

public class DuoTai {
    public static void main(String[] args) {
        Tom tom = new Tom();
        DuoTai d = new DuoTai();
        d.feed(tom);
    }
    public void feed(Tom tom){
      tom.eat();
    }

• 创建一个DouTai的类
  • 只需要写一个方法运用多态来调用所有对象即可

public class DuoTai {
   public static void main(String[] args) {
       Animal tom = new Tom();//多态
       DuoTai a = new DuoTai();//编译看左边,运行看右边
       Animal dog = new Dog();
       a.feed(tom);
       a.feed( dog);
       /*
       多态运行时,成员变量看左边
       多态运行时,静态调用也看左边
        */
       System.out.println(dog.x);
       dog.y();
   }
   public void feed(Animal animal){
       animal.eat();
   }
}