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

继承

基本概念：
A继承自B, A叫做B的子类。B叫做A父类或者基类
一个类只能有一个父类，单继承
则 Java 内置的 Object 类 为父类。因此所有类都直接或者间接继承自 Object。
子类可以继承父类的非private成员，子类可以调用父类的非private 成员

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，只能赋初值

final 类，不能有子类

父类final方法，子类不能重写该方法

抽象类

背景：
比如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();

	}

}