java学习第13天

继承的概念：（个人理解）
抽取子类的共性（属性和方法），再创建一个类将这些共性写里面（这个类称为父类），子类继承（extends）父类，就具备了这些共性（父类的属性和方法）

语法格式： class 子类 父类 extends 父类
特点是：

1. 让类与类之间产生关系，然后子类就可以使用继承，继承父类中非私有的成员
2. 具有传递性，孙子类也可以使用祖辈的非私有的属性和行为

继承的好处：

1. 提高代码的复用性（多个类中相同的成员放到一个类中，再使用extends继承即可）
2. 提高代码的维护性（只需要修改父类中）
   弊端
3. 类与类之间产生了父子关系，当父类发生变化时，子类也发生变化，削弱了子类的独立性

public class Demo01 {
    public static void main(String[] args) {
        Student st=new Student();
    }
}
/**
 * 人类
 */
class Person{
    String name;//姓名
    String num;//身份证号
    String sex;//性别
    //行为
    public void eat(){
        System.out.println(name+"吃饭");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }

    public void playGame() {
        System.out.println(name+"正在打游戏");
    }
}

/**
 * 子类:学生
 */
class Student extends Person{


    public void study(){
        System.out.println(name+"正在学习");
    }
}

/**
 1. 子类:老师
 */
class Teacher extends Person{

    int id;
    public void teaching(){
        System.out.println(name+"正在讲课");

    }
}
/*
*孙子类
*/
class JavaTeacher extends Teacher{
    public void teacherJava(){
        System.out.println(name+"正在上java课!");
    }
}

继承的重写

1. 子类出现了和父类一摸一样的方法声明（方法名和方法参数必须是一致）
   重写的应用场景
   当子类需要父类功能，而且功能主体子类有持有自己的内容的时候，可以重写父类的方法
   这样沿袭了父类的功能，有持有子类特有的内容

两同两小一大：

1. 两同：方法名相同，参数列表相同
2. 两小：返回值类型和抛出异常
3. 一大：父类的访问权限必须小于或等于子类的访问修饰符

返回值类型：

1. void和基本数据类型：父类的返回值类型和子类的返回至类型必须一致
2. 引用数据类型：若父类的方法返回类型是引用数据类型，则该子类重写该方法时，引用数据类型可以是父类本身，可以是父类的子类，也可以是子类本身

抛出异常：

1. 子类抛出异常小于或等于父类方法抛出的异常

public class demo02 {
    public static void main(String[] args) {
        Boo b=new Boo();
        b.name="小刘";
        b.sayHi();

        Coo c=new Coo();
        c.name="小吴";
        c.sayHi();
    }
}
class Aoo{
    String name;
    public  void sayHi(){
        System.out.println("Aoo"+name+"Hi~");
    }
    public Aoo test(){//要求返回Aoo类型的对象
        return new Aoo();//创建Aoo类型的对象,并根据return返回
    }
    public int add(){
        return 10;
    }
}
class Boo extends Aoo{
    //重写
    @Override//标志这下面这个方法是重写
    public void sayHi(){
        System.out.println("Boo"+name+"Hi~");
    }
}
class Coo extends Boo{
    public Boo test(){
        return new Boo();
    }
    public int add(){
        return 10;
    }
//    public Aoo test(){
//        return new Aoo();
//    }
//    public Coo test(){
//        return new Coo();
//    }
}

继承中成员访问的特点
this：代表的是本类对象的引用
super：代表的是父类对象的引用
this&super
成员变量：

1. this.变量名----->表示本类的成员变量
2. super.变量名---->表示访问父类的成员变量

成员方法:

1. this.方法名----->表示访问本类的成员方法
2. super.方法名----->表示访问父类的成员方法

public class Demo03 {
    public static void main(String[] args) {
        B b=new B();
        b.test();
    }
}
class A{
    int age=10;
    public  void show(){
        System.out.println("A的show");
    }
    public void sayHi(){
        System.out.println("A中的sayHi()");
    }
}
class B extends A{
    int age=20;
    public void test(){
        /*
        静态方法(指的是static修饰的方法)
        非静态方法:(没有static修饰的方法) 非静态中有隐式的this传递
         */
        int age=30;
        /*
        若父类和子类以及方法都定义一个age,
        那么在该方法输出age的时候,
        就近原则输出方法中的局部变量中的age的值
         */
        //演示调用this和super
        System.out.println("局部变量"+age);
        System.out.println("B中的age:"+this.age);
        System.out.println("A中的age:"+super.age);

        //演示调用this和super调用成员方法
        //this.sayHi();//调用B类自己的sayHi
        //sayHi();//==this.sayHi() 非静态方法中的特征
        super.sayHi();
    }
    public void sayHi(){
        System.out.println("B中的sayHi()");
    }
}

定义厨师类和收银员类,找到厨师类和收银员类当中的共性内容，抽取出父类员工类，用继承的方式改写代码，并进行测试

1.共性抽取父类，定义员工类(姓名，年龄)

2.定义厨师类，继承员工类，并给出自己特有方法：烹饪()

3.定义收银员类，继承员工类，并给出自己特有方法：收银()

4.定义测试类，写代码测试

public class Test {
    public static void main(String[] args) {
        Chef chef=new Chef("山山",20);
        chef.cooking();
        Cashier cashier=new Cashier("亮亮",21);
        cashier.collectMoney();

    }
}
class Staff{
    String name;
    int  age;
}
/**
 *厨师类
 */
class Chef extends Staff{

    public void cooking(){
        System.out.println("我叫"+name+"\t今年:"+age+"岁了,我会烹饪");
    }
    public Chef(String s,int i){
        name=s;
        age=i;
    }
    public Chef(){
        name=null;
        age=0;
    }
}

/**
 * 收银员类
 */
class Cashier extends Staff{
    public void collectMoney(){
        System.out.println("我叫"+name+"\t今年:"+age+"岁了,我会收钱");
    }
    public Cashier(String s,int i){
        name=s;
        age=i;

    }
    public Cashier(){
        name=null;
        age=0;
    }
}

抽取出Hero和Ep类相同的属性和行为,做一个飞行物类flyobject,然后让hero和Ep类继承该类

再一次调用方法进行测试

public class Test {
    public static void main(String[] args) {
        Hero hero=new Hero();
        hero.moveUP();
        hero.moveDown();
        hero.moveLeft();
        hero.moveRight();
        Ep ep=new Ep();
        ep.move();
    }

}
class FlyObject{
    int x;//横坐标
    int y;//纵坐标
    int w;//飞机宽度
    int h;//飞机的高度
    int hp;//飞机的血量
}
class Hero extends FlyObject{


        //无参构造 初始化赋值
        public Hero(){
            x=200;
            y=600;
            w=100;
            h=50;
            hp=10;
        }
        //成员方法
        public void moveUP(){
            y--;
            System.out.println("英雄机移动后的y值:"+y);
        }
        public void moveDown(){
            y++;
            System.out.println("英雄机移动后的y值:"+y);
        }
        public void moveLeft(){
            x--;
            System.out.println("英雄机移动后的x值:"+x);
        }
        public void moveRight(){
            x++;
            System.out.println("英雄机移动后的x值:"+x);
        }
    }
 class Ep extends FlyObject{

    int type;//敌机的类型
    int sp;//敌机的速度
    //无参构造 初始化赋值
    public Ep(){
        x=10;
        y=10;
        w=20;
        h=20;
        hp=5;
        type=5;
        sp=1;
    }
    public void  move(){
        y++;
        System.out.println("敌机移动后的xy值:"+x+","+y);
    }
}