一．方法重写
1.概念：
Override， 子类出现了和父亲一样的方法声明，此时子类自己特有的功能将父类的方法覆盖掉了。
2.注意事项
1）父类中被private修饰是成员方法，子类不能重写；
2）子类重写父类中的方法，访问权限要足够大，至少要和父类中的方法保持一致。
3）子类要重写父类的静态方法，那么子类也必须为静态，因为静态在编译后所分的内存会一直存在，知道程序退出才会释放这个空间。
3.事例
package practice;
class Father1{
private void show(){
System.out.println("fu");
}
public static void method(){
System.out.println("baba");
}
}
class Son1 extends Father1{
public void show (){
System.out.println("zi");
}
public static void method (){
System.out.println("zizi");
}
}
public class practice2 {
public static void main(String[] args) {
Father1 f = new Father1();
Son1 s = new Son1();
// f.show();
s.show();
f.method();
s.method();
}
}4.final关键字
1）定义：有时候不想让子类去修改父类的数据，这时候Java就提供了一个final关键字；
2）特点：final可以修饰类，该类不能继承；
final可以修饰成员变量，此变量变成常量；final、修饰成员方法，方法不能被重写。
final修饰引用类型时，引用类型的地址值不能再变了，但里面的成员变量可以变化。例： final Student s = new Student; ss.age=23;(T) ss=new Student;(F)
3）扩展
：异常类中，exception释放资源 。finalize：与GC垃圾回收器有关系
4）两种定义方法
Public final int num =10；
Public final int num； num=10；二.多态
1.定义：一个事物在不同时刻时体现出的一种状态。
举例： Animal a =new Cat（）； Animal a= new Dog（）；
2.多态的前提条件
必须有继承关系，又有方法重写，而且是父类的引用指向子类对象（向上转型）。
3.多态的访问特点
成员变量：编译看左（父类中有这个变量，编译通过），运行看左（输出父类中的成员变量值）
成员方法：非静态，编译看左，运行看右，因为存在方法重写
静态，编译和运行都看左
构造方法：对数据进行初始化的
4多态的好处
1）提高了代码的复用性，由继承保证；
2）提高了代码的扩展性，父类指向子类对象。
例：
package practice;
class Animal{
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep(){
System.out.println("猫睡觉");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
public void sleep(){
System.out.println("狗睡觉");
}
}
class AnimalTool{
public static void useAnimalTool(Animal a){
a.eat();
a.sleep();
}
}
public class practice3 {
public static void main(String[] args) {
Cat c1= new Cat();
Cat c2= new Cat();
AnimalTool.useAnimalTool(c1);
AnimalTool.useAnimalTool(c2);
Dog d1= new Dog();
Dog d2= new Dog();
AnimalTool.useAnimalTool(d1);
AnimalTool.useAnimalTool(d2);
}
}5.多态的弊端
不能访问子类中的特有功能
例：
class Fu{
public void method(){
System.out.println("method Fu...");
}
}
class Zi extends Fu{
public void method(){
System.out.println("method Zi....");
}
public void show(){
System.out.println("show Zi...");
}
}
//测试类
public class DuoTaiDemo3 {
public static void main(String[] args) {
//父类引用指向子类对象
Fu f = new Zi() ;
f.method();
// f.show() ;子类的特有功能
}
}6.解决多态中的弊端问题
1)使用子类的功能,创建子类对象可以,使用子类对象调用子类中的功能,可以,但是不够好,又重新new对象,
在堆内存中消耗内存,所以不好!
2)向上转型:父类的引用指向子类对象
可不可以将父类的引用转型子类对象呢?可以:向下转型:是将父类的引用强制转换成子类对象
例：
class Fu2{
public void method(){
System.out.println("method Fu...");
}
}
class Zi2 extends Fu2{
public void method(){
System.out.println("method Zi....");
}
public void show(){
System.out.println("show Zi...");
}
}
public class DuoTaiDemo4 {
public static void main(String[] args) {
//父类引用指向子类对象
Fu2 f = new Zi2() ;//父类引用指向子类对象
f.method();
// f.show()
// Zi2 z = new Zi2() ;
// z.show() ;
Zi2 z = (Zi2) f ; //将内存中的子类对象还原成子类对象!
z.show() ;
}
}7.向下转型的问题
向下转型使用不当会出现异常，因为只能还原一次
运行的时候发生ava.lang.ClassCastException:类转换异常!
例：
class Animal2{
public void eat(){}
public void sleep(){}
}
class Cat2 extends Animal2{
}
class Dog2 extends Animal2 {
}
//测试类
public class DuoTaiDemo5 {
public static void main(String[] args) {
//父类引用指向子类对象
Animal2 a= new Cat2() ; //内存指向的猫
Cat2 c = (Cat2) a ; //内存:还原成猫
a = new Dog2() ; //内存指向狗
Dog2 d = (Dog2) a ; //还原成狗
Cat2 c2 = (Cat2)a; //属于向下转型的语法:但是运行错误:内存指向问题:猫执行狗的对象.
}
}三.抽象类
1.定义
抽象类的格式: abstract class Animal{} //动物类是一个抽象类
抽象的方法的格式: 是没有方法体的,并且public abstract
public void show(){} //有方法特的方法不是抽象方法
public abstract void show() ;
2.特点
1)抽象类有抽象方法,也可以有非抽象方法。但如果一个类中有抽象方法,那么这个类就必须定义为抽象类。
2)抽象类中也有构造方法
3) 抽象类的子类:非抽象类:有意义的,因为使用的就是子类的功能,通过子类对象给父类(抽象类)间接的实例化
抽象类:子类的抽象类,没有意义,因为使用的就是子类的具体功能
4）抽象类不能直接实例化，该类不能创造对象，就要用到子类像，可以通过子类对象间接实例化， Fu f = new Zi（）；
3.成员特点
成员变量：可以是变量也可以是自定义常量；
成员方法：可以是抽象也可以是非抽象的；
构造方法：可以是无参也可以是有参。
4.特性
强制要求子类重写父类抽象类中的抽象方法，由抽象类保证子类继承父类，代码的复用性由继承保证、
5.注意事项
1）如果一类中没有抽象方法，那么这个类也可以定义为抽象类，为了不创建对象。
2）abstract和static，private，final不能冲突
四.接口
1.格式
接口体现的是事物的一种扩展功能，比如猫跳高，这些功能不是一开始就具有的，而是一种额外的动作和功能。
接口: interface + 接口(命名规范:和类名的命名规范一样) inteface Jump{}
2.特点
1）接口的方法只能是抽象方法；
2）接口不能实例化，不能创建对象；
3）接口的子类为实现类，子实现类是抽象类则没有意义，子类是非抽象类，则接口可以通过子类进行实例化。AnimalTrain at = new Cat() ; //接口多态的形式
4）子实现类和接口的关系:---->implements:实现的意思；
5）子实现类要实现接口中所有的抽象方法。
6）接口的成员特点 成员变量：默认的修饰符，public，final，abstract
成员方法：抽象方法，默认修饰符abstract，public
构造方法：接口中没有构造方法
3.例子
interface Inter{
public final static int num3 = 30 ;
public abstract void method();
}
//在实际的开发中,给接口的实现类起名字:接口名+Impl
class InterImpl implements Inter{
@Override
public void method() {
System.out.println("今天天气很热,地表温度爆表!");
}
}
//测试类
public class InterfaceDemo2 {
public static void main(String[] args) {
//创建对象:接口多态
Inter i = new InterImpl() ;
i.method() ;
}
}4.题目
1）*类与类,类与接口,类与接口的关系:
类与类:继承关系:单继承,不能多继承,但是可以多层继承；
类与接口的关系:实现关系:implements:可以单实现,也可以多实现，并且还可以在继承一个类的同事实现多个接口；
接口和接口的关系:继承关系:可以单继承,可以多继承。
class Son extends Object implements Father,Monther{ }
2）接口和抽象类的区别?
A:成员的区别:成员变量:抽象类:可以是变量,也可以是常量 接口:只能是常量
成员方法:抽象类:可以抽象方法或非抽象方法 接口:只能是抽象方法
构造方法:抽象类:可以是有参构造,也可是无参构造 接口:没有构造方法
B:设计原则的区别:抽象是一种"is a"的关系,由继承保证
接口:是事物一种扩展功能,只需子实现类进行实现即可,体现是一种"like a" 的关系:跳高猫(部分猫具有这样的功能)
C.应用场景:实际的开发中会到
具体类对象(很少使用)
抽象类多态(一般会使用)
接口多态(经常常用)
