java中继承、多态、final、抽象类、接口、匿名类

爱被打了一巴掌 2022-04-22 00:54 205阅读 0赞

### 文章目录 ###

*   *   *  继承
         *  多态
         *  类型转换
         *  final 关键字
         *  抽象类
         *  inteface
         *  匿名类

### 继承 ###

**基本概念：**  
A继承自B, A叫做B的子类。B叫做A父类或者基类  
一个类只能有一个父类，单继承  
则 Java 内置的 Object 类 为父类。因此所有类都直接或者间接继承自 Object。  
子类可以继承父类的非private成员，子类可以调用父类的非private 成员  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70]

Car 主类—FengTian 子类

public class Car {
        
    	
    	private String color;
    	private int lunNum;
    	
    	//定义构造函数
    	public Car()
    	{
        
    	}
    	// 设置颜色
        public void setColor(String color)
        {
        
        	this.color=color;
        }
        
        public String getColor()
        {
        
        	return this.color;
        }
        // 设置轮子个数
    	public int getLunNum() {
        
    		return lunNum;
    	}
    	public void setLunNum(int lunNum) {
        
    		this.lunNum = lunNum;
    	}
    	// 输出车的轮子和颜色
    	public void sayhello()
    	{
        
    		System.out.println(" 这是一辆车，价格不知道，颜色是"+this.color+",轮子个数是"+this.lunNum);
    	}
    
    
    
    //   继承了Car 的所有方法
    public class FengTian extends Car{
        
    
    	private int price;
    	private String name;
    	
    	public FengTian()
    	{
        
    		
    	}
    
    	public int getPrice() {
        
    		return price;
    	}
    
    	public void setPrice(int price) {
        
    		this.price = price;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    	
    	
    	
    	public void zhanshi()
    	{
        
    		// 调用父类的方法 sayhello
    		this.sayhello();
    		System.out.println("this price is "+this.price);
    	}
    }
    
    //Main
    
    public class Main {
        
    
    	public static void main(String[] args) {
        
    
    		//初始化一辆车设置颜色和轮子个数
    		Car c=new Car();
    		c.setColor("yellow");
    		c.setLunNum(4);
    		c.sayhello();
    		
    		// 丰田车初始化,继承了类Car
    		FengTian fengtian= new FengTian();
    	    fengtian.setPrice(15000);
    	    //调用父类的方法
    		fengtian.setColor("red");
    		fengtian.zhanshi();
    	}
    
    }

### 多态 ###

//父类类型的变量可以指向子类类型的变量,反过来不行  
//能够调用什么方法取决于变量的类型  
//调用哪个实现方法取决于对象的类型

父类：DiQiuRen 子类 Chinese

public class DiQiuRen {
        
    	
    	
    	//新建构造函数
    	public DiQiuRen()
    	{
        
    		
    	}
    	
    	public void speak()
    	{
        
    		System.out.println("i speak 地球语言");
    	}
    
    }
    
    
    public class Chinese  extends DiQiuRen{
        
    	//构造函数
    	public Chinese()
    	{
        
    		
    	}
    
    	//  重写方法  或者叫覆盖
        
    	@Override
        public void speak()
        {
        
        	System.out.println("i 说 中国话");
        }
        
    	
        public void baiNian()
        {
        
        	System.out.println("过年好");
        }
    
        
    }
    
    
    public class Main {
        
    
    	public static void main(String[] args) {
        
    		
    		//父类对象创建
    		DiQiuRen d1= new DiQiuRen();
    		d1.speak();
    		
    		//子类创建对象
    	    Chinese c1=new Chinese();
    	    c1.speak();
    	    
    	    
    	    //多态使用
    	    //父类类型的变量可以指向子类类型的变量,反过来不行
    	    //能够调用什么方法取决于变量的类型
    	    //调用哪个实现方法取决于对象的类型
    	    // 输出中国人，因为对象是Chinese
    	    DiQiuRen d2=new Chinese();
    	    d2.speak();
    	    
    	}
    
    }

### 类型转换 ###

DiQiuRen d1= new Chinese();  
// 显示转换  
Chinese c= Chinese(d1);

instanceof 运算符，判断某一个变量指向的对象，是否属于某个类  
例如：  
dqr instanceof Chinese； 假设为true  
Chinese 是DiQIuRen的子类  
dqr instanceof DiQiuRen ; 也是true

### final 关键字 ###

**局部变量是final，只能赋初值**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 1]

**final 类，不能有子类**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 2]

**父类final方法，子类不能重写该方法**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 4]

### 抽象类 ###

背景：  
比如DiQiuRen 中speak()方法 不知道如何实现，只能有子类实现。 这样就需要定义抽象方法和抽象类

*  抽象类不一定要有抽象方法。
 *  有抽象方法的类一定是抽象类
 *  抽象类的子类，若是非抽象类，那必须要实现父类所有的抽象方法（除非这个子类还是抽象类）
 *  抽象类不能被实例化
 *  抽象方法没有方法体，而且关键字顺序最好不能错  
    public abstract void speak();

// 抽象类 父类 DiQiuRen
    //抽象类
    public abstract class DiQiuRen {
        
    
    	//抽象方法
    	public abstract void speak();
    	public abstract void walk();
    	//非抽象方法
    	public void sing()
    	{
        
    		System.out.println("sing one song");
    	}
    }
    
    // 非抽象类，子类Chinese
    public class Chinese extends DiQiuRen {
        
    
    	@Override
    	public void speak() {
        
    	System.out.println("speak chinese");
    	}
    
    	@Override
    	public void walk() {
        
    		// TODO Auto-generated method stub
    		System.out.println("walk..walk");
    		
    	}
    	}

### inteface ###

用于声明能力，不能实例化，只能被类实现。

*  接口中只能有抽象方法，不能有其他，因为默认为接口，所以方法不用写abstract
 *  一个类可以实现多个接口，用关键字 implement
 *  接口一般用able后缀。  
    抽象类与接口区别  
    相同点：  
    都可以定义抽象方法  
    不同点：  
    1 抽象类中可以有具体非抽象方法。 而接口中全部是抽象方法  
    2 一个子类只有1个父类，一个类可以实现多个接口  
    3 接口中不可以定义成员变量，抽象类中可以定义成员变量

//   定义一个接口，代表一种能力声明
    public interface Speakable {
        
    
    	public void speak();
    	public void sing();
    	
    
    }
    
    
    
    public interface Runnable {
        
    	public void run();
    
    }
    
    // 1个类可以实现多个接口
    public class Speak implements Speakable,Runnable {
        
    
    	@Override
          public void speak() {
        
    		// TODO Auto-generated method stub
    		System.out.println("speak chinese");
    		
    	}
    
    	@Override
    	public void sing() {
        
    		// TODO Auto-generated method stub
    		System.out.println("sing");
    		
    	}
    
    	@Override
    	public void run() {
        
    		// TODO Auto-generated method stub
    		
    	}
    	}

### 匿名类 ###

有的子类只被调用一次。 那么可以用匿名类  
语法：

继承如下的类名  
new 类名() \{  
类体  
\};

注意：

*  一般不在匿名类中额外定义方法，因为很难被调用。 所以一般重写Override父类的方法。  
    也可以用接口编写匿名类。  
    speakable s=new speakable()  
    \{  
    类体 Override等  
    \};

public class Main {
        
    
    	public static void main(String[] args) {
        
    			int j=666;
    		// 定义一个匿名类
    		DiQiuRen d1 = new DiQiuRen() {
        
    
    			//匿名类中 一般不会再定义变量或者方法
    			// 因为匿名类只被初始化一次
    			private int i;
    			public int getI() {
        
    				return i;
    			}
    			public void setI(int i) {
        
    				this.i = i;
    			}
    
    			@Override
    			public void sing() {
        
    			// 可以在匿名类中访问局部变量i。 JDK1.8
    				System.out.println("walk and walk"+j);
    
    			}
    
    		};
    		
    		d1.sing();
    
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70]: /images/20220422/e9ad9e3ade004ee1b49c819268bbc310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 1]: /images/20220422/896dc1113331422485a07553448690d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 2]: /images/20220422/bc788fe45e2e4688b3608ce3a7ac645b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 3]: /images/20220422/694ba14bd333487bb95b4c7b568bc885.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI1MTc4Mw_size_16_color_FFFFFF_t_70 4]: /images/20220422/63d8f60218024287a72451cb25332e9d.png