Java6 2021.6.29

抽象类
1、抽象方法和抽象类必须要用abstract修饰符来定义，有抽象方法的一定是抽象类，抽象类可以不用抽象方法
2、抽象方法不能有方法体：就是{}括起来的部分，后面直接封号；即可
3、抽象类不能被实例化，无法用new来调用抽象类构造器创建抽象类实例
4、抽象类可以包含：成员变量，方法，构造器，初始化块，内部类（接口，枚举）
5、含有抽象方法的类（直接定义抽象方法，继承抽象父类但没有完全实现抽象方法，实现了一个接口但没有完全实现接口包含的抽象方法，都算的）只能被定义为抽象类

package practice;
import java.util.*;
public abstract class Main{
	{
		System.out.println("执行shape初始化块");
	}
	private String color;
	public abstract double calPerimeter();
	public abstract String getType();
	public Main() {}//创建Main子类实例时调用
	public Main(String color) {
		System.out.println("执行有参数构造器");
		this.color=color;
	}
}

普通类继承抽象类后要实现抽象类里所有的方法

package practice;
import java.util.*;
abstract class M{
	{
		System.out.println("执行shape初始化块");
	}
	private String color;
	public abstract double calPerimeter();
	public abstract String getType();
	public M() {}//创建Main子类实例时调用
	public M(String color) {
		System.out.println("执行有参数构造器");
		this.color=color;
	}
}
public class Main extends M{
	private int a;
	private int b;
	private int c;
	public Main(String color,int a,int b,int c) {
		super(color);
		this.setSides(a,b,c);
	}
	public void setSides(int a,int b,int c) {
		if(a>=b+c||b>=a+c||c>=a+b) {
			return;
		}
		this.a=a;
		this.b=b;
		this.c=c;
	}
	public double calPerimeter() {
		return (double)a+b+c;
	}
	public String getType() {
		return "三角形";
	}
}

M类型的引用变量，指向Main对象

package practice;
import java.util.*;
abstract class M{
	{
		System.out.println("执行shape初始化块");
	}
	private String color;
	public abstract double calPerimeter();
	public abstract String getType();
	public M() {}//创建Main子类实例时调用
	public M(String color) {
		System.out.println("执行有参数构造器");
		this.color=color;
	}
}
public class Main extends M{
	private double radius;
	public Main(String color,double radius) {
		super(color);
		this.radius=radius;
	}
	public double calPerimeter() {
		return 2*Math.PI*radius;
	}
	public String getType() {
		return getColor()+"圆";//调用方法，把抽象类里的变量值调出来
	}
	public static void main(String[] args) {
		M s1=new Main("黑色",3);//M类型的引用变量，指向Main对象
	}
}

final跟abstract水火不容，static跟abstract水火不容
父类普通方法依赖abstract方法

package practice;
import java.util.*;
abstract class M{
	private double turnRate;
	public M() {}//用于子类建造对象
	public abstract double getRadius();
	public void setTurnRate(double turnRate) {
		this.turnRate =turnRate;
	}
	public double getSpeed() {
		return java.lang.Math.PI*2*getRadius()*turnRate;
	}
}
public class Main extends M{
	public double getRadius() {
		return 0.28;
	}
	public static void main(String[] args) {
	Main m=new Main();
	m.setTurnRate(15);
	}
}