【Java学习笔记】抽象，多态及方法重写

一．方法重写

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）扩展

             Finally：异常类中，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.应用场景:实际的开发中会到
9e6b

具体类对象(很少使用)

抽象类多态(一般会使用)

接口多态(经常常用)