Java基础学习三————面向的继承和多态

Java学习三————面向的继承和多态
继承提高了程序的可维护性，多态提高了程序的可扩展性。
1.继承
继承可以实现代码的复用，子类可以继承父类的除私有属性和方法的所有属性和方法。

extends 可以表示继承关系

Java中不允许多继承，即可以一个父类有多个子类，一个子类不能有多个父类
Java接口可以多继承

当父类的方法不能自满足子类的需求，就可以对该方法重写。重写时访问权限只能扩大，返回值类型不变。

@Override：子类重写父类的标识。

super 可用以指向父类的方法，如super.eat()
在子类的默认无参构造方法中，有这样一个语法：
public man(){
//指向父类的无参构造方法
super(); 这是默认的，不写出来也会有
}

2.多态
概念：多种状态，同一对象在不同情况下表现出不同的状态或行为。
必须有继承存在，才能有多态
调用成员方法时，编译器看左边，运行器看右边
调用成员变量时，编译看左，运行看右。
父类成员方法可以重写，成员变量不可以。
不能使用子类特有成员，需要使用子类特有成员，就需要转型。
多态分为两个阶段：编译阶段和运行阶段
（1）向下转型：把子类的引用指向父类的对象
如：子类Cat定义了一个属于自己的方法，父类想要调用这个方法
则可以Cat cat1 = (Cat)animal;
类似于C语言的类型强制转换，这里是把animal的引用强转为Cat类型

（2）向上转型：把父类的引用指向子类的对象
如：父类有一个eat方法，想要调用子类中被重写后的eat方法。
Animal animal = new Cat();用Animal类型（父类）来接收new出的对象（子类）。

多态的好处：
提高了程序的可维护性（由继承保证）
提高了程序的可扩展性（由多态保证）
多态的弊端：
不能访问子类的特有功能
如何访问子类的特有功能：向下转型

instanceof：x instanceof y,用来判断x是否是y的对象。

tips：向下转型并不属于多态，它只是一种访问子类特有功能的手段。

主人喂养宠物的案例：
主人喂养多个宠物，如猫cat，狗dog，兔子等等
所有宠物都有一个eat()方法，主人有feed方法，用一个test类进行喂养测试
一、采用对feed进行重载，每一个宠物对应一个feed方法，每增加一个宠物类就需要增加一个feed方法和一个对象。
但这样的程序耦合度高，可扩展性不强。
二、给所有宠物建立一个共有父类pet，所有宠物都继承pet
pet中定义一个eat()方法，然后给主人类定义一个feed方法，参数为（Pet pet），父类的引用指向子类的对象

主人Master

package com.jy.master;

public class Master {

    public void feed(Pet pet){
        pet.eat();

    }
}

宠物猫Cat

package com.jy.master;

public class Cat extends Pet {

    public void eat(){
        System.out.println("猫吃鱼");
    }
}

宠物狗Dog

```java
package com.jy.master;

public class Dog extends Pet {

    public void eat(){

        System.out.println("狗吃骨头");
    }
}

宠物

package com.jy.master;

public class Pet {


    public void eat(){

    }
}

场景，即喂养测试

```java
package com.jy.master;

import javafx.animation.ScaleTransition;

public class MasterTest {

    public static void main(String[] args){

        Master master = new Master();

        Pet pet = new Pet();

        Cat cat = new Cat();

        Dog dog = new Dog();

        master.feed(cat);

        master.feed(dog);
    }
}

这种方法的好处：耦合度低，可扩展性强，增加一个宠物只需加一个类，不需要修改主人Master的代码。

static关键字
可以修饰方法和属性
成员变量可以分为实例变量和静态变量
private String name; //实例变量
private static String name; //静态变量，被本类所有对象共享
没有static修饰的方法称为实例方法，是对象级别的，调用实例方法需要创建对象。
如Demo demo = new Demo()
demo.main
用static修饰过的方法或者属性是类级别的，会在类加载的时候加载。调用时是不需要创建对象的，可以直接用类名调用,如Demo.main.
但创建对象也可以调用静态方法。
静态变量是存放在方法区的。
静态方法中没有对象this，所以不能访问非静态成员。

静态代码块
写在类中，不能写在方法中，在类加载的时候会与之加载。
定义：static{
}
执行时静态代码块会在方法之前执行。
所有的方法运行时开辟的空间都在栈内存中，包括静态方法，但静态属性和静态代码块在方法区。
静态代码块只执行一次，执行一次后就已经开辟空间了，不需要再次开辟。

final关键字
代表的是最终的。可以修饰类、方法和属性。
final修饰类时，类不能被继承。如String类，本身已经是最终类
final修饰方法时，该方法不能被重写
final修饰属性时，如果final修饰的是一个基本数据类型的变量，那么这个变量就是常量，它的值就定了，不能变了，而如果修饰的是一个引用变量，那么该变量存的是一个内存地址，该地址就不能变了，但是该内存地址所指向的那个对象还是可以变的。
不建议修饰引用数据类型，因为仍可以通过修改对象的内部数据进行改变，意义不大。

用static和final共同修饰的变量是公共的常量（类级），命名是所有字母都需要是大写，之间用“_”连接，如GUO_JI,常量的访问权限修饰符可以public，也可private，因为值已经不可变了。

不能与abstract共存

抽象类
包含抽象方法的类，用abstract修饰
抽象方法：只有方法声明，没有方法体的方法，用abstract修饰
当需要定义一个方法，却不明确方法的具体实现时，可以将方法定义为abstract，具体实现延迟到子类，子类中必须重写该方法。
例如：public abstract void eat();

特点：
1.必须用abstract修饰
1）修饰符 abstract 类名{}
2）修饰符 abstract 返回类型 方法名{}
2.抽象类不能被实例化，只能由具体的子类实例化，创建子类对象
3.抽象类子类的两个选择：
1）重写父类的所有抽象方法
2）定义成抽象类
4.成员变量
1）可以有普通的成员变量
2）也可以有成员常量
5.成员方法
1）可以有普通方法，也可以有抽象方法
2）抽象类不一定有抽象方法，有抽象方法的类一定是抽象类（或接口）
6.像普通类一样有构造方法，可以重载。

接口
接口技术用于描述类具有什么功能，但是不给出具体实现，类要遵从接口描述的统一规则进行定义，所以接口是对外提供的一组规则、标准。
接口用关键字interface表示
格式：interface{}
类实现接口用implements表示
格式：class 类名 implements 接口名{}
接口没有成员变量，只有公有的、静态的常量。
接口不能实例化，也没有需要初始化的成员，没有构造方法。
接口是特殊的抽象类，里面全是抽象方法，没有普通方法
接口中定义的变量会默认加上public abstract
1.接口不能实例化，需要创建其子类对象来完成实例化操作，即接口的多态。
2.接口的子类
1）如果是普通类，则必须重写接口中所有的抽闲方法
2）如果是抽象类则不用重写接口中的抽闲方法
3.接口和类的关系
1）类与类之间
继承关系只能单继承，不能多继承，可以多层继承
2）类与接口之间
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
3）接口与接口之间
继承关系，可以单继承，也可以多继承
4.对于一个类来讲，它的父类（继承的关系）中定义的都是：共性内容
5.对于一个类来讲，它的接口（实现的关系）中定义的都是：扩展内容