JAVA_SE_Day16

抽象类与抽象方法 关键字(abstract)

• 可以用来修饰类和方法

abstract修饰类

• 将一个父类设计的非常抽象,没有具体的实例,叫做抽象类
• 修饰的类不能被实例化
• 抽象类中一定有构造器，便于子类实例化时的调用
• 开发中，实例化抽象类的子类，完成相关的操作

abstract修饰方法

• 抽象方法只有方法的生米功能，没有方法体 格式如 : public abstract void show();
• 包含抽象方法的类，一定是一个抽象类.相反抽象类中不一定要定义抽象方法
• 如果子类重写了父类中所有的抽象方法，则子类可以实例化
  如果子类没有重写父类中的所有抽象方法,则子类也是一个抽象类，需要使用abstract修饰

接口(interface)

• 接口的本质是契约，规范，标准
• 类和接口是并列的两个结构
• 接口中不能定义构造器，接口不能被实例化
• 开发中，接口痛殴类去实现(implements)的方式来使用
  如果实现类覆盖了接口中所有的抽象方法，则实现类就可以实例化
  如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
• java类可以实现多个接口 格式如 A extends B implements CC,DD{}
• 接口和接口之间可以继承
• JDK7.0及以前 只能定义全局常量和抽象方法
  1.全局常量 public static final 的，可以省略不写
  2.抽象方法 public abstract ,可以省略不写
• JDK8.0 除了定义全局常量和抽象方法之外，还可以定义静态方法和默认方法
  1.权限默认都是public
  2.接口中定义的静态方法，只能通过接口来调用 格式 接口.静态方法名
  3.如果实现类重写了接口中的默认方法，调用的是重写后的方法
  4.继承父类和接口，同名的方法会优先调用父类的方法
  5.实现类调用接口的默认方法 格式 接口名.super.默认方法名()

内部类

• 在JAVA中，允许一个类的定义位于另外一个类的内部，前者称为内部类，后者称为外部类
• 分类 成员内部类(静态和非静态) 和 局部内部类

public class Test {
	public static void main(String[] args) {
		//Person类抽象了,就不能实例化
		//Person p1 = new Person();
		Stduent s = new Stduent();
		s.show();
		s.speak();
		
		// 模版方法
		Template t = new SubTemplate();
		t.spendTime();
	}

}

interface Fly{
	// 全局变量
	public static final int Max_SPEND = 100;
	int MIN_SPEND = 1;// 省略了public static final
	// 抽象方法
	public abstract void tryFly();
	void stopIt();// 省略了 public abstract
}

interface Eat{
	void eat();// 省略了 public abstract
	//  静态方法(有代码块的)
	public static void show() {
		
	}
	// 默认方法
	public default void show1() {
	}
}

class FlyImpl implements Fly,Eat{
	@Override
	public void tryFly() {
		System.out.println("i can fly");
	}
	@Override
	public void stopIt() {
		System.out.println("i must to stop it");
	}
	@Override
	public void eat() {
		System.out.println("i want to eat");
	}
}









// 抽象类 计算某段代码运行所需要的时间
abstract class Template{
	public void spendTime() {
		long start = System.currentTimeMillis();
		code();// 不确定的部分
		long end = System.currentTimeMillis();
		System.out.println("花费时间 "+(end - start));
	}
	// 抽象方法
	public abstract void code();
}

class SubTemplate extends Template{

	@Override
	public void code() {
		// TODO Auto-generated method stub
		for (int i = 2 ; i <= 1000  ; i++) {
			boolean flag = true;
			for (int j =2 ; j <= Math.sqrt(i); j++) {
				if (i % j == 0 ) {
					flag = false;
					break;
				}
			}
			if(flag) {
				System.out.println(i);
			}
		}
		
	}
	
}















abstract class God{
	public abstract void speak();
}

// 抽象类
abstract class Person extends God{
	String name;
	public Person(){}
	public Person(String name){
		this.name = name;
	}
	// 抽象方法
	public abstract void show();
	public void eat() {
		System.out.println("eat");
	}
}
class Stduent extends Person{
	@Override
	public void show() {
		System.out.println("Stduent show!");
	}
	@Override
	public void speak() {
		System.out.println("Stduent speak!");
	}
}

class A{
	// 非静态成员内部类
	class CC{}
	// 静态成员内部类
	static class DD{}
	// 方法
	public void method() {
		// 局部内部类
		class B{
		}
	}
}