第二章：Java面向对象：抽象（abstract）类、模板方法设计模式、接口（interface）、关键字-implements(实现)、代理模式

package com.atguigu.java;
/*
 * Abstract关键字的使用：
 * 1.abstract:抽象的
 * 2.abstract可以用来修饰：类、方法
 * 
 * 3.abstract 修饰类：抽象类
 * >此类不能实例化
 * >抽象类中一定有构造器，便于子类对象实例化的时候使用（子类对象实例化的全过程）
 * >在开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
 * 
 * 
 * 4.abstract 修饰方法：抽象方法
 * >抽象方法只有方法的声明没有方法体。
 * >包含抽象方法的类，一定是一个抽象类。反之，抽象类中是可以没有抽象方法的。
 * >若子类重写了父类中 所有 的抽象方法后，此子类方可实例化
 *   若子类没有重写父类中 所有 的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰一下。
 * 
 * 
 */
public class AbstractTest {
	public static void main(String[] args) {
		//一旦person类抽象了，就不能再实例化了！
//		Person p1  = new Person();
//		p1.eat();
	}
}
abstract class Person{
	String name;
	int age;
	public Person(){
		
	}
	public Person(String name,int age){
		this.age = age;
		this.name = name;
	}
	//不是抽象方法
//	public void eat(){
//		
//	}
	//抽象方法：
	public abstract void eat();
	
	public void walk(){
		System.out.println("人走路");
	}
}

 class Student extends Person{
	
	public Student(){
		
	}
	
	public Student(String name,int age){
		this.age = age;
		this.name = name;
	}
	
	public void eat(){
		System.out.println("学生多吃有营养的食物");
	}
	
}

package com.atguigu.java;
/*
 * abstract使用上的注意点：
 * 1.abstract不能用来修饰：属性、构造器等结构
 * 2.abstract不能用来修饰：私有方法（不能被重写）、
 * 静态方法（重写的都是非static的）、 以及final修饰的类和方法
 */
public class AbstractTest1 {

}

package com.atguigu.java;

/*
 * 抽象类的应用：模板方法的设计模式
 */
public class TemplateTest {
	public static void main(String[] args) {

		SubTemplate t = new SubTemplate();

		t.spendTime();
	}
}

abstract class Template {
	// 计算某段代码执行所需要花费的时间
	public void spendTime() {
		long start = System.currentTimeMillis();

		this.code();// 不确定的部分、易变的部分,就抽象一下，然后子类再去确定

		long end = System.currentTimeMillis();

		System.out.println("花费时间：" + (end - start));

	}

	// 抽象方法：必须存在在抽象类中，子类必须重写
	public abstract void code();
}

class SubTemplate extends Template {
	@Override
	public void code() {
		for (int i = 0; i <= 1000; i++) {
			boolean isFlage = true;
			for (int j = 2; j <= Math.sqrt(i); j++) {
				if (i % j == 0) {
					isFlage = false;
					break;
				}
			}
			if (isFlage) {
				System.out.println(i);
			}
		}
	}
}

package com.atguigu.java1;

/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.Java和类是并列的结构
 * 3.如何定义接口：定义接口的成员
 * 
 * 		3.1 JDK7及以前：
 * 				        只能够去定义全局常量和抽象方法
 * 					>全局常量：public static final的,但是书写时是可以省略的，但是仍然存在。
 * 					>抽象方法：public abstract,但是书写时是可以省略的，但是仍然存在。
 * 
 *      3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
 *      
 * 4.接口中是不能定义构造器的！意味着接口是不能实例化的。
 * 
 * 5.Java开发中，既然不能实例化，接口通过让类去实现(implements)的方式来使用。
 * 如果实现类覆盖了接口中的所有抽象方法，那么这个实现类就可以实例化了
 * 但是如果实现类不能覆盖所有的抽象方法，则此实现类仍为抽象类，也就不能实例化。
 * 
 * 6.Java类可以实现多个接口----->弥补了Java单继承性的局限性
 * 格式：class AA extends BB implements CC,DD,MM{
 *     
 *             }
 *             
 * 7.接口和接口之间可以继承，而且可以多继承
 * 
 * *********************************************************************
 * 
 * 8.接口的具体使用，体现多态性！
 * 
 * 9.接口实际上可以看作一种规范！
 * 
 * 
 */
public class InetrfaceTest {
	public static void main(String[] args) {

		System.out.println(Flyable.MAX_SPEED);// 直接通过接口调用，体现的是静态（static）
		System.out.println(Flyable.MIN_SPEED);// 直接通过接口调用，体现的是静态（static）
		// Flyable.MAX_SPEED = 8;会报错，体现的是final

		Plane p = new Plane();
		p.fly();

	}
}

interface Attackable {
	void attack();//省略了
}

interface Flyable {
	// 全局常量：
	public static final int MAX_SPEED = 7900;// 第一宇宙速度

	int MIN_SPEED = 1;

	// 抽象方法：
	public abstract void fly();

	void stop();
}

class Plane implements Flyable {

	@Override
	public void fly() {
		System.out.println("通过引擎起飞");
	}

	@Override
	public void stop() {
		System.out.println("驾驶员减速降落");
	}
}

class Kite implements Flyable {
	@Override
	public void fly() {

	}

	@Override
	public void stop() {

	}
}
class Bullet extends Object implements Flyable,Attackable,CC{

	public void attack() {
		
	}

	public void fly() {
		
	}
	public void stop() {	
	}

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}
}
//**********************************
interface AA{
	void method1();
}
interface BB{
	void method2();
}
//多继承
interface CC extends AA,BB{
	
}

package com.atguigu.java1;

/*
 * 接口的应用：代理模式 
 * 
 */
public class NetWorkTest {
	public static void main(String[] args) {
		ProxyServer proxyServer = new ProxyServer(new Server());
		proxyServer.browse();
	}
}

// 接口
interface NetWork {
	public void browse();

}

// 被代理，真实的服务器
class Server implements NetWork {

	@Override
	public void browse() {
		System.out.println("连接服务器");

	}

}

class ProxyServer implements NetWork {

	private NetWork work;

	public ProxyServer(NetWork work) {// 构造器，给属性初始化
		this.work = work;
	}

	public void check() {
		System.out.println("检查网络问题");
	}

	@Override // 真正地去联网的是服务器
	public void browse() {
		check();
		work.browse();
	}

}