java旅途《JAVA基础第五章》《抽象类接口》

抽象类

父类只有定义没有实现叫做抽象类

abstract

用 abstract 修饰的就叫做抽象

抽象类

用abstract 修饰的类叫做抽象类

抽象方法

用abstract 修饰的方法叫做抽象方法

父类定义方法结构没有实现。子类继承父类之后实现方法。

模板方法设计模式

模板方法基本上父类定义结构由子类去实现里面逻辑或者父类完成部分逻辑有不同的逻辑交给各个子类去实现。

接口

定义

接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现
用interface来定义。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有方法都默认是由public abstract修饰的。
接口没有构造器。
一个类可以实现多个接口，接口采用多继承机制。

工厂

将类的实例化延迟到工厂类的子类中完成，即由子类来决定应该实例化哪一个类。

public interface IWorkFactory{
	Work getWork();
}

public interface Work{
	void doWork();
}

public class StudentsWork implements Work{
	@Override
	public void doWork(){
		System.out.println("学生写作业");
	}
}

public class StudentsWorkFactory implements IWorkFactory{
	@Override
	public Work getWork(){
		return new StudentsWork();
	}
}

public class TecherWorkFactory implements IWorkFactory{
	@Override
	public Work getWork(){
		return new TeacherWork();
	}
}

public class TeacherWork implements Work{
	@Override
	public void doWork(){
		System.out.println("老師批改作業");
	}
}

public class TestFactoryMethod{
	public static void main(String[] args){
		IWorkFactory i = new StudentsWorkFactory();
		i.getWork().doWork();
		
		IWorkFactory i1 = new TecherWorkFactory();
		i1.getWork().doWork();
	}
}

代理模式

代理模式其实通俗意义讲的话 你想买个东西，不直接去拥有者买，去第三方或者类似中介去买。再或者老板交代你的开发任务。不直接给你发邮件，给你们开发经理，开发经理在给你发邮件让你开发个功能。第三方、中介、开发经理都是代理类，好处就是可以随意对代理类扩展新的功能但是不影响委托类(实际执行类)，符合开闭原则

静态代理

public interface InterfaceObject{
	void action();
}

public class ObjectImpl implements InterfaceObject{
	@Override
	public void action(){
		System.out.println("=========被代理類執行了============");
		System.out.println("=========具體操作=============");
		System.out.println("=========被代理類執行完成===========");
	}
}

public class ProxyObject implements InterfaceObject{
	InterfaceObject obj;

	public ProxyObject(){
		System.out.println("代理類創建成功");
		obj = new ObjectImpl();
	}
	
	@Override
		public void action(){
			 System.out.println("代理類開始執行");
			 obj.action();
			 System.out.println("代理類執行完成");
		}
}

public class TestProxy{
	public static void main(String[] args){
		InterfaceObject obj =  new ProxyObject();
		obj.action();
	}
}

动态代理

动态代理其实动态代理实际执行类
1、创建一个实现InvocationHandler的类，实现invoke方法，可以增加自己的逻辑结构，比如说增加日志请求。
2、Proxy.newProxyInstance 创建代理类
3、执行委托类方法

public interface Human{
	void info();
	void fly();
}

//被代理类
public class SuperMan implements Human{

	@Override
	public void info(){
		System.out.println("我是超人，我怕谁");
	}

	@Override
	public void fly(){
		System.out.println("I CAN FLY");
	}

}

public class MyInvocationHandler implements InvocationHandler {
    Object obj;

    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil hum = new HumanUtil();
        hum.method1();
        Object val = method.invoke(obj, args);
        hum.method2();
        return val;
    }

}

public static void main(String[] args){
		Human su = new SuperMan();//被代理类对象
		MyInvocationHandler my = new MyInvocationHandler(su);
		Human hu = (Human)Proxy.newProxyInstance(su.getClass().getClassLoader(), su.getClass().getInterfaces(), my);
		hu.info();
		hu.fly();
	}

内部类

允许一个类的定义位于另一个类的内部

public class InnerClass{
	String name = "hanmeimei";
	int age;

	// 成员内部类
	/**
	 * 1、四个访问修思付 
	 * 2、static final修饰 
	 * 3、具体类的特点 abstract 定义属性、方法、构造器
	 * 4.可以调用外部的属性。方法
	 * 掌握
	 * 1、如何创建成员内部类cmm、yjq
	 * 2、如何调用外部类，内部类的变量（尤其是重名时）
	 * 3、局部内部类的使用
	 */
	public class cmm{
		String name = "cmm";
		int age;

		public cmm(){
			// TODO Auto-generated constructor stub
		}
		public void setName(String name){
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(InnerClass.this.name);
		}
	}
	
	public static class yiq{
		
	}

	// 局部内部类（方法里）
	public void show(){
		class yjq{

		}
	}
}