Java面向对象3

继承

继承的概述

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。

继承的格式&使用
在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。
格式：
class 子类 extends 父类 {}

public class ExtendsDemo {
    public static void main(String[] args) {
        DotA1 d = new DotA1();
        d.start();

        LOL1 l = new LOL1();
        l.start();
    }
}

class Game1 {
    String name;
    double version;//版本号
    String agent;//代理商

    public void start() {
        System.out.println("游戏启动了");
    }

    public void stop() {
        System.out.println("游戏关闭了");
    }
}

class DotA1 extends Game1 {
    /*String name;
    double version;//版本号
    String agent;//代理商

    public void start() {
        System.out.println("游戏启动了");
    }

    public void stop() {
        System.out.println("游戏关闭了");
    }*/
}

class LOL1 extends Game1 {
    /*String name;
    double version;//版本号
    String agent;//代理商

    public void start() {
        System.out.println("游戏启动了");
    }

    public void stop() {
        System.out.println("游戏关闭了");
    }*/

}

继承的特点

Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹）
Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）

在类的继承中，需要注意一些问题，具体如下：

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。
class A{}
class B{}

2、多个类可以继承一个父类，例如下面这种情况是允许的。
class A{}
class B extends A{}
class C extends A{} // 类B和类C都可以继承类A

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。
class A{}
class B extends A{} // 类B继承类A，类B是类A的子类

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类

public class ExtendsDemo2 {
    public static void main(String[] args) {
        LOL l = new LOL();
        l.update();
        l.start();
    }
}

class Game {
    public void start() {
        System.out.println("游戏启动了");
    }
}

class PCGame extends Game {
    public void update() {
        System.out.println("PCGame更新了");
    }
}

class MobileGame extends Game {
    public void update() {
        System.out.println("MobileGame更新了");
    }
}

class LOL extends PCGame {

}

继承中成员变量的特点

A:子类只能获取父类非私有成员
子父类中成员变量的名字不一样直接获取父类的成员变量
子父类中成员变量名字是一样的获取的是子类的成员变量

B:就近原则：谁离我近我 就用谁
如果有局部变量就使用局部变量
如果没有局部变量，有子类的成员变量就使用子类的成员变量
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量

C: super:可以获取父类的成员变量和成员方法,用法和this是相似的

public class ExtendsDemo3 {
    public static void main(String[] args) {
        Kid3 k = new Kid3();
        k.show();
    }
}

class Dad3 {
    String name = "建霖";
}

class Kid3 extends Dad3 {
    String name = "四葱";

    public void show() {
        String name = "五葱";

        System.out.println(super.name);
        System.out.println(this.name);
        System.out.println(name);
    }
}

继承中成员方法的特点&方法重写

A:子类中没有这个方法,调用父类的

public class ExtendsDemo4 {
    public static void main(String[] args) {
        Kid4 k = new Kid4();
        k.eat();
    }
}

class Dad4 {
    public void eat() {
        System.out.println("小酌两口");
        System.out.println("去睡觉了");
    }
}

class Kid4 extends Dad4 {

}

B: 子类中重写了这个方法，调用子类的方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法

public class ExtendsDemo4 {
    public static void main(String[] args) {
        Kid4 k = new Kid4();
        k.eat();
    }
}

class Dad4 {
    public void eat() {
        System.out.println("小酌两口");
        System.out.println("去睡觉了");
    }
}

class Kid4 extends Dad4 {
    public void eat() {
        System.out.println("好好吃饭");
    }
}

方法重写的应用场景&注意事项

*方法重写的注意事项：*
        不可以重写父类私有的成员方法，压根就看不到父类的私有成员
        子类重写父类方法，权限必须大于等于父类方法的权限

*注解*
        @Override：方法重写，说明下面的方法是重写父类的方法      

public class ExtendsDemo5 {
    public static void main(String[] args) {
        NewPhone np = new NewPhone();
        np.call();
    }
}

class Phone {
    void call() {
        System.out.println("打电话");
    }
}

class NewPhone extends Phone {

    @Override
    public void call() {
        System.out.println("录音");
        //System.out.println("打电话");

        //super.call();
    }
}

继承中构造方法的执行顺序

A:super(实参列表);语句  在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用

B:this(实参列表); 语句  在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用

public class ExtendsDemo6 {
    public static void main(String[] args) {
        //Die d = new Die();
        Zi6 z = new Zi6();
    }
}

class Die6 {
    public Die6() {
        System.out.println("我是父类无参构造");
    }

    public Die6(int num) {
        System.out.println("我是父类有参构造");
    }
}

class Zi6 extends Die6 {
    public Zi6() {
        //super(1);
        //super();

        this(1);//不会再调用父类的无参构造了

        System.out.println("我是子类无参构造");
    }

    public Zi6(int num) {
        //会默认调用父类无参构造
        System.out.println("我是子类有参构造");
    }
}   

this与super区别

    this:当前对象的引用
        调用子类的成员变量
        调用子类的成员方法
        在子类的构造方法第一行调用子类其他构造方法
    super:子类对象的父类引用
        调用父类的成员变量
        调用父类的成员方法
        在子类的构造方法第一行调用父类的构造方法

public class ExtendsDemo7 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.function();
    }
}

class Die {
    int num = 10;

    public Die() {
        System.out.println("我是父类无参构造");
    }

    public Die(int num) {
        System.out.println("我是父类有参构造");
    }

    public void method() {
        System.out.println("我是父类的方法");
    }
}


class Zi extends Die {
    //int num = 30;

    public Zi() {
        //this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
        super();
        System.out.println("我是子类无参构造");
    }

    public Zi(int num) {
        System.out.println("我是子类有参构造");
    }

    public void method() {
        System.out.println("我是子类的方法");
    }

    public void function() {
        //this.num = 50;
        //System.out.println(num);
        //this.method();

        //super.num = 40;
        //super.method();

        System.out.println(this.num);
    }

继承优缺点

A:优点
提高了代码的复用性
提高了代码的可维护性

B:缺点：
类的耦合性增强了
开发的原则：高内聚低耦合
内聚：就是自己完成某件事情的能力
耦合：类与类的关系

匿名对象&final

匿名对象定义&使用

匿名对象即无名对象,直接使用new关键字来创建对象

public class AnonymousObejctDemo {
    public static void main(String[] args) {
        method(new Student());

    }

    public static void method(Student s) {

    }


}


class Student {
    String name;
    int age;

    public void study() {
        System.out.println("好好学习，高薪就业");
    }
}

final关键字

final： 修饰符，可以用于修饰类、成员方法和成员变量
final所修饰的类：不能被继承，不能有子类
final所修饰的方法:不能被重写
final所修饰的变量：是不可以修改的，是常量

抽象类

抽象类概述

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

抽象类的特点：

抽象方法只能在抽象类里面
抽象类和抽象方法必须被abstract修饰
抽象类不能创建对象（不能实例化）
抽象类中可以有非抽象的方法
抽象类和类的关系也是继承
一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类  

public class AbstractDemo2 {
    public static void main(String[] args) {
    }
}

abstract class Animal2 {
    public abstract void eat();

    public void run() {

    }
}

class Cat2 extends Animal2 {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
    }

}

抽象类的成员的特点

    成员变量
        可以有成员变量
        可以有常量
    成员方法
        可以有抽象方法
        可以有非抽象方法
    构造方法
        可以有构造方法的，需要对抽象类的成员变量进行初始化

public class AbstractDemo3 {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.barking();
    }
}

abstract class Animal {
    String name = "哮天犬";
    final int num = 10;

    public Animal() {
        System.out.println("我是抽象类的构造方法");
    }

    public abstract void eat();

    public void run() {}
}

class Dog extends Animal {
    public void barking() {
        System.out.println(name);
        System.out.println(num);
    }

    @Override
    public void eat() {
        // TODO Auto-generated method stub

    }
}

雇员案例

雇员类:
属性:姓名,编号,薪水
行为:工作
程序员:
属性:姓名,编号,薪水
行为:写代码工作
经理:
属性:姓名,编号,薪水,奖金
行为:盯着程序员写代码工作

public class AbstractTest2 {
    public static void main(String[] args) {
        Programmer p = new Programmer();
        p.work();

        Manager m = new Manager();
        m.work();
    }
}

abstract class Employee {
    String name;//姓名
    String id;//id
    double pay;//薪水

    //工作
    public abstract void work();

}

class Programmer extends Employee {

    @Override
    public void work() {
        System.out.println("写代码");
    }

}

class Manager extends Employee {
    byte bonus;

    @Override
    public void work() {
        System.out.println("盯着程序员写代码");
    }

}

抽象类的细节

*A:抽象类关键字abstract可以和哪些关键字共存?*
1.private：
私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起 使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
2.final: 
抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类
抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写   
3.static:

*B:抽象类中是否可以不定义抽象方法?*
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用

*C:抽象类是否有构造函数?*
   有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化