第二章：Java面向对象:abstract(抽象)、模板设计模式、匿名子类、接口（interface)、implements（实现）、代理模式、工厂模式、JDK8接口新特性、内部类、成员内部类实例化

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.java;
/*
 * 关于抽象类的匿名子类：
 * 
 */

public class PersonTest{

//匿名对象，造的是Student类的对象，只不过是对象没有没有名字了
	public static void main(String[] args) {
		Worker worker = new Worker();
		method1(worker);//非匿名的类 非匿名的对象
		method1(new Worker());//非匿名的类 匿名的对象
		
		//创建了一个匿名子类的对象p
		Person p = new Person(){

			@Override
			public void eat() {
				System.out.println("吃东西");
				
			}
			
		};
		method1(p);
		System.out.println("********************");
		//匿名子类的匿名对象
		method1(new Person(){
			@Override
			public void eat() {
				System.out.println("吃一点东西");
				
			}
		});
	}
	
	public static void method1(Person p){
		p.eat();
	}
	
	public static void method(Student s){
		
	}
	
}
class Worker extends Person{

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

package com.atguigu.java1;

/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.Java和类是并列的结构
 * 3.如何定义接口：定义接口的成员
 * 
 * 		3.1 JDK 7 及以前：
 * 				        只能够去定义全局常量和抽象方法
 * 					>全局常量：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();
	}

}

package com.atguigu.java1;

/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 */
public class USBTest {
	public static void main(String[] args) {
		Computer c = new Computer();
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		c.transferDate(flash);
		//2.创建接口的非匿名实现类的匿名对象
		c.transferDate(new Printer());
		//3.创建接口的匿名实现类的非匿名对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手机开始工作");
				
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
				
			}
			
		};
		c.transferDate(phone);
		//4.创建接口的匿名实现类的匿名对象
		c.transferDate(new USB(){

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

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

	}
}

class Computer {
	public void transferDate(USB usb) {
		usb.start();
		System.out.println("传输细节");
		usb.stop();
	}
}

interface USB {
	// 定义了长宽最大最小传输速度
	void start();

	void stop();
}

class Flash implements USB {

	@Override
	public void start() {
		System.out.println("优盘开启工作");

	}

	@Override
	public void stop() {
		System.out.println("优盘结束工作");
	}

}

class Printer implements USB {

	@Override
	public void start() {
		System.out.println("打印机开始工作");

	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");

	}

}

package com.atguigu.java8;

/*
 * JDK8及以后在接口中除了可以定义全局常量、抽象方法之外，还可以定义静态方法和默认方法。
 * 
 * 
 */
public interface ComperA {

	// 静态方法 public可以省略
	public static void method1() {
		System.out.println("北京");
	}

	// 默认方法 public可以省略，但是权限还是public 不是缺省的
	public default void method2() {
		System.out.println("上海");
	}

	default void method3() {
		System.out.println("上海");
	}
}

package com.atguigu.java8;

public class SubClassTest {
	public static void main(String[] args) {
		SubClass s = new SubClass();

		// s.method1();//异常：The method method1() is undefined for the type
		// SubClass
		// 知识点1：接口中定义的静态方法，只能通过接口来调用
		ComperA.method1();// 就是想接口直接用

		s.method2();
		// 知识点3：
		// 类优先原则--->：如果子类（或者实现类）继承的父类和实现的接口中声明了同名同参数的方法，
		// 那么子类（或者实现类）在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。
		// 知识点4：如果类实现了多个接口，接口中定义了同名同参数的默认方法，
		// 那么在实现类没有重写此方法的情况之下，报错---->接口冲突。
		// 那这就需要我们在实现类中重写此方法。
		s.method3();

		// 知识点2：通过 实现类的 对象 可以直接调用接口的默认方法
		// 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
	}
}

class SubClass extends SuperClass implements ComperA, Compare8 {
	public void method2() {
		System.out.println("你好上海");
	}

	public void method3() {
		System.out.println("深圳！");
	}

	// 知识点5：如何在子类（或者实现类）的方法中调用父类、接口中被重写的方法。
	public void myMethod() {
		method3();// 调自己的方法
		super.method3();// 父类中的同名方法
		ComperA.super.method3();// 接口中的同名方法
		Compare8.super.method3();// 另一个接口中的同名方法
	}
}

package com.atguigu.java2;

import java.lang.reflect.Method;
import java.text.Bidi;

/*
 * 类的内部成员之五：内部类
 * 1.Java允许将一个类A声明在另一个类B中，则A为内部类，B为外部类
 * 
 * 2.内部类的分类：成员内部类（直接定义在类内:静态、非静态）  vs 局部内部类（方法内、代码块内、构造器内）
 * 
 * 3.成员内部类：
 * 			一方面：作为外部类的成员：
 * 					>可以调用外部类的结构
 * 					>可以被static修饰
 * 					>可以被四种不同的权限修饰符修饰
 * 
 * 			另一方面：作为一个类出现的：
 * 					>类内，可以定义属性、方法、构造器、代码块、内部类
 * 					>类可以用final修饰，表示此类不能被继承，言外之意，不使用final就可以被继承（extends）
 * 					>可以被abstract修饰，表示此类不能实例化，
 * 
 * 4.关注如下的3个问题：
 * 4.1如何实例化成员内部类的对象
 * 
 * 4.2如何去在成员内部类中区分调用外部类的结构
 * 
 * 4.3开发中局部内部类的使用：见InnterClassTest
 */
public class InnerTest {
	public static void main(String[] args) {

		// 创建Dog实例（静态的(static)成员内部类）
		Person.Dog dog = new Person.Dog();
		dog.shot();
		// 创建Bird实例（非静态的成员内部类）

		// Person.Bird bird = new Person.Bird();//错误的，不能直接调用
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		bird.display("抖抖");

	}
}

class Person {
	// 属性
	String name = "小明";
	int age;

	// 方法
	public void eat() {
		System.out.println("吃饭");
	}

	// 静态成员内部类
	static class Dog {
		String name;

		public Dog() {
			super();
		}

		public Dog(String name) {
			super();
			this.name = name;
		}

		public void shot() {
			System.out.println("我是一只狗");
		}
	}

	// 非静态成员内部类
	class Bird {
		String name = "杜鹃";

		public void sing() {
			System.out.println("我是一只鸟");
			Person.this.eat();// 调用外部类的非静态方法。
		}

		public void display(String name) {
			System.out.println(name);// 形参
			System.out.println(this.name);// 内部类的属性
			System.out.println(Person.this.name);// 外部类的属性
		}
	}

	public void method() {

		// 局部内部类：方法内
		class AA {

		}

	}

	{
		// 局部内部类：代码块内
		class BB {

		}
	}

	public Person() {
		// 局部内部类:构造器内
		class BB {

		}
	}
}

package com.atguigu.java2;

public class InnterClassTest {
	
	//开发中也很少见
	public void method() {

		// 局部内部类：方法内
		class AA {

		}

	}
	public Comparable getComparable(){
		
		//方式一：
//		//创建一个实现了Comparable接口的类:局部内部类
//		class MyComparable implements Comparable{
//
//			@Override
//			public int compareTo(Object o) {
//				// TODO Auto-generated method stub
//				return 0;
//			}
//			
//		}
//		return new MyComparable();
		
		//方式二：创建匿名实现类的匿名对象
		return new Comparable(){

			@Override
			public int compareTo(Object o) {
				return 0;
			}
			
		};
		
	}
}

package com.atguigu.java2;

public class MyTest {
	public static void main(String[] args) {

		Person.Dog dog = new Person.Dog();

		Person p = new Person();

		Person.Bird bird = p.new Bird();
	}
}

class Person {

	static class Dog {

	}

	class Bird {

	}
}