第七次笔记

继承

儿子继承父亲
优点:儿子可以使用父亲的功能 提高代码的复用性
继承使用场景
Student Dog Car Person
要使用继承关系必须满足:xxx 是xxx
例如:学生是人 ,老师是人,狗是动物
Student 继承Person
Teacher 继承 Person
Dog 继承 Animal;
继承是面向对象程序设计思想,提高代码的复用性,可扩展性,
创建一个Animal类

package day07note;
public class Animal {
    //创建一个动物类
    public  Animal(){
        System.out.println("Animal的无参构造");
    }
    private  String name;
    private int age;
    public void eat(){
        System.out.println("动物吃");
    }
    public void sleep(){
        System.out.println("动物睡");
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Dog类

package day07note;
//创建一个Dog类
/*
狗是动物,继承Animal类,继承父类的行为属性(非私有的)
一个类只能直接继承一个父类,
public class Dog extends Animal 为显示继承
public class  Animal 没有显示继承其他类的时候,此时这个类默认继承object类
public class  Animal extend object
object 类是Java中所有类的基类(父类  超类)
 */
public class Dog extends Animal {
    public  Dog(){
        System.out.println("Dog的无参构造");
    }
    public Dog(String type){
        super();
        this.type=type;
        System.out.println("Dog有参构造方法");
    }
    private  String type;
        public void play(){
            System.out.println("狗会玩");
        }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

package day07note;
/*Animal默认继承了object;;Dog 继承了Animal XiaoTianQuan继承了Dog相当于XiaoTianQuan继承了三个类*/
public class XiaoTianQuan extends Dog{
    /*
     * 构造方法的作用是初始化类的成员*/
    public XiaoTianQuan(){
        //super("牧羊犬");//调用父类的构造方法;默认存在,如果要用super()显示调用只能放在构造方法的第一行,(原因:先保证父类的初始化)
        System.out.println("哮天犬的无参构造方法");

    }
    public void fly(){
        System.out.println("哮天犬会飞");
    }
}

package day07note;

public class Test {
    public static void main(String[] args) {
        /*父类的*/
        Dog wc=new Dog();
        wc.setName("旺财");
        wc.setAge(2);
        wc.eat();
        wc.sleep();
        /*自己的*/
        wc.setType("牧羊犬");
        wc.play();
        System.out.println(wc.getName());
        System.out.println(wc.getAge());
        System.out.println(wc.getType());

        XiaoTianQuan xiaoTianQuan=new XiaoTianQuan();
        xiaoTianQuan.setName("哮天犬");
        xiaoTianQuan.setAge(5000);
        xiaoTianQuan.setType("中华田园犬");
        xiaoTianQuan.eat();xiaoTianQuan.fly();
        System.out.println(xiaoTianQuan.getAge());
        System.out.println(xiaoTianQuan.getName());
        System.out.println(xiaoTianQuan.getType());

    }
}

输出结果:

当创建一个子类对象时,会在子类的构造方法中取调用父类的构造方法,先去初始化父类,默认会在构造方法的第一行使用super()调用,如果显示的使用super()调用,也必须放在构造方法的第一行,可以使用super()传参数调用指定的构造方法,

package day07note;

public class Test1 {
    public static void main(String[] args) {
        /*
        * 构造方法的作用是初始化类的成员*/
        XiaoTianQuan xtq = new XiaoTianQuan();
    }
}
/*
结果表明子类的构造方法总是先调用父类的方法;
 */

结果

使用super()传参数调用指定的构造方法,
使用前:

代码:

结果:

super方法重写

注意：构造方法,静态方法不能重写,成员变量不存在重写
方法的重写
应用场景:
当父类的方法实现不能满足子类需求时, 可以对方法进行重写( override)
在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重写规则
方法名相同、参数列表相同；
返回值类型相同；
访问权限不能小于父类权限;
@Override//java中的注解标签 强化说明此方法为父类中重写过来的,在编译期间,就会对语法进行校验,

package day07note;

public class Cat extends Animal {
    /*当父类实现代码不能满足子类中的需求,可以在子类中将父类的方法重写,也成为方法的覆盖 ,复写*/

    @Override//java中的注解标签   强化说明此方法为父类中重写过来的,在编译期间,就会对语法进行校验,
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        super.sleep();
    }
}

package day07note;

public class Test2 {
    public static void main(String[] args) {
        Dog wc =new Dog();
        wc.setName("旺财");
        wc.play();
        Cat m=new Cat();
        m.eat();//此时m调用的为Cat类中重写的eat()方法;
    }
}

结果:

抽象类

抽象方法
	抽象方法是一种特殊的方法：它只有声明，而 没有具体的实现. 
	 抽象方法必须用abstract关键字进行修饰

有抽象方法一定是抽象类,但抽象类中不一定有抽象方法;

package day07note.cxff;
/*如果一个类中还没有包含足够的信息(抽象方法)来描绘一个具体的对象,这样的类就是抽象类*/
//一般用在体系结构的顶层,用来进行功能的声明;
public abstract class Animal {
    /*抽象方法:只有方法体,没有具体的实现*/
    //抽象类可以拥有构造方法,不能创建对象
      int num;
      public Animal(){
          System.out.println("Animal的无参构造");
      }
    public abstract void eat();//在比较顶级的类中定义一个方法即可;
    //抽象类中还可以放其他
    public  void sleep(){
        System.out.println("动物睡觉");
    }
}

package day07note.cxff;
//继承抽象类两种方法
//1.重写抽象类中的抽象方法: @Override public void eat() {
//2.将要继承的这个类也写成抽象类;

public class  Dog extends Animal{
    public Dog(){
        super();
    }
    @Override
    public void eat() {//重写eat()
        System.out.println("狗吃定西");
    }

   /* @Override
    public void sleep() {//重写sleep()
       // super.sleep();//表明父类可以实现;
        System.out.println("狗睡觉");
    }*/
}

package day07note.cxff;

public class Test {
    public static void main(String[] args) {
        Dog wc = new Dog();
        System.out.println(wc.num);//调用父类的
        wc.eat();//调用重写的
        wc.sleep();//若在Dog中没有重写则调用父类的
    }
}

结果:

多态

封装,包装
继承 子继承父
多态:
同一种事物,在不同时刻表现不同的状态
满足三个条件:
要有继承
要有方法重写
父类引用指向子类对象
LIst list=new ArrayList();
Object obj=new Car();

  		 obj=new Dog();
  		 boj=new Cat();

public  abstract class Animal {
    public void sleep(){
        System.out.println("动物睡觉");
    }
    public abstract void eat();
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Cat  extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        Animal a=new Dog();
        a.sleep();
        a.eat();
        a=new Cat();
        a.eat();
    }
}

结果:

多态语法

public  abstract class Animal {
    int num=10;
    public static void sleep(){
        System.out.println("动物睡觉");
    }
    public abstract void eat();
}

public class Dog extends Animal{
    int num=20;
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public static void sleep(){
        System.out.println("狗睡觉");
    }
}

public class Cat  extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public static void sleep(){
        System.out.println("猫睡觉");
    }
}

package day07note.duotai;

public class Test1 {
    /*设计一个喂动物的方法,传入具体的动物对象,*/
    public static void main(String[] args) {
        Test1 w=new Test1();
        Cat cat =new Cat();
       // w.feedCat(cat);
        Dog dog=new Dog();
        //w.feedDog(dog);
        /*多态的有点,提高程序的扩展性*/
        w.feedAnimal(dog);
        w.feedAnimal(cat);

    }
/*    public void feedCat(Cat cat){
        cat.eat();
    }
    public void feedDog(Dog dog){
        dog.eat();
    }*/
    public void feedAnimal(Animal animal){
        animal.eat();
    }
}

结果: