Java多态&抽象类&接口

野性酷女 2022-06-06 00:28 293阅读 0赞

**一.多态**

**定义：多态指一个事物在不同时刻体现出来的不同状态**

**1）多态存在的三个必要条件**

1.要有继承；

2.要有重写；

方法重写：要求返回值类型也要相同的.不能改变返回值类型

3.父类引用指向子类对象。（向上转型）（三者缺一不可，必须熟记）

**2）多态的成员访问特点:**  
 成员变量:  
  编译看左边,运行看左边  
 成员方法:  
  编译看左,运行看右;由于存在方法重写,所以就运行最终的就是子类的成员方法  
 静态成员方法:  
  编译看左,运行看左  
 构造方法:还是对象进行初始化,由于是一种继承关系,还是分层初始化!

**3）多态的好处及弊端？如何解决多态的弊端？**

多态的好处:  
  a.提高代码的维护性 多态对已存在代码具有可替换性(由继承保证)  
  b.提高代码的扩展性(由多态保证)

c.多态简化对应用软件的代码编写和修改过程  
 多态的弊端:  
不能访问子类的特有功能  
  
**解决方案:**  
  a.创建子类的具体对象,来访问自己的特有功能;虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆内存开辟空间,  
  
  b.将子类的引用指向父类对象即向下转型:将父类的引用强制转换为子类的引用（前提必须有父类的引用存在）;  
Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

**关于转型：**

比如有2个类 A B A继承B 先 B b = new B()**;** 这个时候 A a = b; 这种用法就是向上转型 使用父类的引用 引用子类对象 向上转型是自动的不需要其他操作 在上边的基础上  b =  (B) a 这个就是向下转型 当用父类引用 引用子类对象 现在想不使用父类的引用 而使用子类的引用 就是向下转型 向下转型必须强制转型 必须确定对象确实是子类对象

**关于final的问题**

final关键字可以干什么?有什么特点?  
  
       final关键字可以用来修饰类，修饰类的成员变量，修饰成员方法。  
       特点：如果修饰类则该类不能被继承，如果修饰成员方法则改方法不能被重写，如果修饰成员变量则该成员变量不能被修改。大多数情况，final一般跟public static一起使用！     
  
3:final关键字的面试题?  
    A:修饰局部变量  
    B:初始化时机  
        A   基本数据类型：如果局部变量是基本数据类型被final修饰后，其值不能被改变。  
                          引用数据类型：如果引用类型被final修饰，那么就不能再重新分配堆内存空间，但可以改变成员变量的值！      
        B   初始化时机：构造代码块中可以进行初始化。  
                        构造方法中可以进行初始化。  
                        定义成员变量的时候可以进行初始

**\*局部内部类访问局部变量时 该局部变量要作为一个常量被final修饰**

class Outer5{
    	//外部类的成员变量
    //	public int num = 100 ;
    	private int num = 100 ;
    	
    	//外部类的成员方法
    	public void method(){
    		//局部变量
    		 final int num2 = 200 ;	//自定义常量(细节问题)
    		
    		//局部位置
    		class Inner5{
    			//局部内部类的成员方法
    			public void show(){
    				System.out.println(num);
    				
    				//局部内部类中访问局部变量
    				System.out.println(num2); //jdk1.7才会有这个错误!		jdk1.8---->封装好了,所以不会出现错误!
    			}
    		}
    		
    		Inner5 i = new Inner5() ;
    		i.show() ;
    	}
    }

二. 抽象类

概念：使用了关键词abstract声明的类叫作“抽象类“。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract，当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类：使用了关键词abstract声明的类叫作“抽象类“。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract，当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类

1）抽象类成员特点?  1.抽象方法:没有方法体的一个方法 public abstract void eat() ; 2.抽象的子类 abstract class Cat extends Animal{
         1.抽象方法:没有方法体的一个方法 public abstract void eat() ; 2.抽象的子类 abstract class Cat extends Animal{

}

抽象类的子类的特点:    抽象类的子类是抽象类,那么没有意义!最终使用的就是通过子类进行对象初始化的,如果子类都被抽象修饰了,那么也不能创建对象,所以没意义 2）关于抽象类：   抽象类的子类是抽象类,那么没有意义!最终使用的就是通过子类进行对象初始化的,如果子类都被抽象修饰了,那么也不能创建对象,所以没意义 2）关于抽象类：

a.一个抽象类如何进行实例化:
    通过抽象类多态形式:父类的引用指向子类对象,通过子类进行初始化!一个抽象类如何进行实例化:
    通过抽象类多态形式:父类的引用指向子类对象,通过子类进行初始化!

b.一个抽象类中可以有非抽象方法吗?
    一个抽象类中可以抽象,也可以有非抽象的
    c.抽象类不能实例化:抽象类不能创建对象一个抽象类中可以有非抽象方法吗?
    一个抽象类中可以抽象,也可以有非抽象的
    c.抽象类不能实例化:抽象类不能创建对象

3）抽象类多态:  
  强制子类必须重写当前抽象的父类中所有的抽象方法  
  还可以提高代码的维护性(里面继承关系保证!)

\* 抽象类的小问题     A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?     B:abstract不能和哪些关键字共存         A.  可以，不能让创建对象。         B.  final    private   static 和 abstract不能共存

三.接口
    1).接口的概述及其特点?
    1).接口的概述及其特点?

概述：接口体现的是一种扩展功能。        特点：接口里面的方法只能是抽象方法。

Interface  接口名｛
                 ｝
                 接口不能实例化，必须通过过子实现类进行初始化。因此子实现类不能为抽象类，否则没有意义。
                 class 子实现类名 implements 接口名｛
              ｝

**2).接口的成员特点?**  1.成员变量:

只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)
      	2.构造方法:
      		接口是没有构造方法的
     	3.成员方法:
     		接口中的成员方法默认修饰符:public abstract
    3).抽象类和接口的区别?		只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)
      	2.构造方法:
      		接口是没有构造方法的
     	3.成员方法:
     		接口中的成员方法默认修饰符:public abstract
    3).抽象类和接口的区别?

1.成员的区别:
     	成员变量:
     		抽象类:成员变量可以是常量,也可以是变量
     		接口:成员变量只能是一常量:存在默认修饰符:public static final
     	构造方法:
     		抽象类:可以有无参构造,有参构造方法
     			作用:通过子类进行数据初始化(通过子类创建对象)
     		接口:没有构造方法的
     	成员方法的区别:
     		抽象类:可以有抽象方法,也可以有非抽象方法
     		接口:只能是抽象方法:存在默认修饰符:public abstract
     				
    2.关系的区别:
     	类与类的关系:
      		继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
      	类与接口的关系:
      		实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
     		(class 子实现类名  enxtends Object implements 接口名1,接口名2...)
      			
      	接口与接口的关系
      				继承关系:extends,可以支持单继承,也可以多继承!
      						
      3.设计理念的区别:
      		抽象类:
      			体现的是一种"is a"的关系,存在继承关系!(抽象类多态)
      		接口:
      			体现的是一种"like a"的关系,由于接口的一种扩展功能
    *接口练习题	成员变量:
     		抽象类:成员变量可以是常量,也可以是变量
     		接口:成员变量只能是一常量:存在默认修饰符:public static final
     	构造方法:
     		抽象类:可以有无参构造,有参构造方法
     			作用:通过子类进行数据初始化(通过子类创建对象)
     		接口:没有构造方法的
     	成员方法的区别:
     		抽象类:可以有抽象方法,也可以有非抽象方法
     		接口:只能是抽象方法:存在默认修饰符:public abstract
     				
    2.关系的区别:
     	类与类的关系:
      		继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
      	类与接口的关系:
      		实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
     		(class 子实现类名  enxtends Object implements 接口名1,接口名2...)
      			
      	接口与接口的关系
      				继承关系:extends,可以支持单继承,也可以多继承!
      						
      3.设计理念的区别:
      		抽象类:
      			体现的是一种"is a"的关系,存在继承关系!(抽象类多态)
      		接口:
      			体现的是一种"like a"的关系,由于接口的一种扩展功能
    *接口练习题

老师和学生案例,加入抽烟的额外功能

分析:具体到抽象
     学生:
      			成员变量:姓名,年龄
     			构造方法:有参/无参
     			成员方法
     老师:
      成员变量:姓名,年龄
      			构造方法:有参/无参
     			成员方法
     
    人类:persen类:抽象类	     eat();抽象功能
                    学生继承自persen
     		老师继承自persen
                    部分学生和老师具有吸烟功能:
     		接口:	smoking  的抽象功能
     实现:抽象到具体
    			成员变量:姓名,年龄
     			构造方法:有参/无参
     			成员方法
     老师:
      成员变量:姓名,年龄
      			构造方法:有参/无参
     			成员方法
     
    人类:persen类:抽象类	     eat();抽象功能
                    学生继承自persen
     		老师继承自persen
                    部分学生和老师具有吸烟功能:
     		接口:	smoking  的抽象功能
     实现:抽象到具体

package org.westos_08_接口; //测试类 public class Test { public static void main(String[] args) { SmokingStudent ss = new SmokingStudent(); ss.setName("吴彦祖"); ss.setAge(21); System.out.println(ss.getAge()+" "+ss.getName()); ss.sleep(); ss.eat(); ss.study(); ss.smoking(); System.out.println("---------------------"); //有参构造数据初始化 ss = new SmokingStudent("彭于晏",20); System.out.println(ss.getAge()+" "+ss.getName()); ss.sleep(); ss.eat(); ss.study(); ss.smoking(); } }

![Center][]

[Center]: /images/20220606/3ba1e15e9bf54f6aa20598b07e0ac686.png