1.java 面向对象（接口、内部类）

1.1 接口

• 接口是一种标准，一个规范 和类是一个级别
  • 就像所有的电源插头与插座一样 所有厂家都做的三线插头和二线插头这样就能相互使用。
• 语法:
  • 【访问权限修饰符】 interface 接口名 { 接口中的内容 }
    • 访问权限修饰符： public公共的（所有地方都可以访问）默认（package）本包内访问
    • JDK1.7
      • 静态常量：默认【public static final】 类型=常量
      • 抽象方法：默认【public abstract】返回值 方法名();
    • JDK1.8
      • 默认方法：deault 返回值 方法名（）{ }
        • 作用：实现接口的类进行重写，如果实现接口的类没有重写该方法，可以由子类对象堆该方法进行调用
      • 静态方法：static 返回值 方法名(){ }
        • 接口中的静态方法调用是通过：接口名.静态方法(); 因为该静态方法属于接口，不属于对象
        • 可以被接口的实现类重写，但该静态方法不能被父类对象（声明接口类型的对象）调用
    • JDk1.9
      • 可以创建私有（private）的方法
• 接口的特点
  • 接口不能被实例化（不能通过new 来创建对象）
  • 接口被实现的关键字（相当于子父类中的extends） implement
    • class 类名 implement 接口名{}
  • 一个类只能有一个直接父类，但是可以实现多个接口：实现类的多继承
    • class 类名 【extends 父类】 implement 接口1，接口2{}
  • 接口之间实现（继承）用 extends
    • interface 接口名1 extends 接口名2，接口名3{}
• 接口使用场景： （接口描述的是一个功能）
• 总结：跟抽象类抽象方法的使用方法差不多 如果接口中使用的default默认方法 调用接口方法的时候可以不重写

1.2 代理模式（静态代理）

• 分类：静态代理
  • 特点：代理类和被代理类实现了同一个接口的方法，兵去在代理类中传入了被代理类的对象

//客户
public class TestClient { 
	public static void main(String[] args) { 
		ProxyObject proxy=new ProxyObject(new SubjectImpl());
		proxy.action();
	}
}
//接口 方法 （房子）
interface Subject{ 
	void action();
}
//代理类 中介
class ProxyObject implements Subject{ 
	SubjectImpl sub=null;
	public ProxyObject(SubjectImpl sub) { 
		this.sub=sub;
	}
	@Override
	public void action() { 
		sub.action();
	}
}
//被代理类 业主
class SubjectImpl implements Subject{ 
	@Override
	public void action() { 
		System.out.println("租房业务");
	}
}

1.3 内部类（类的第五个成员）

• 类的成员： 属性 方法 构造器 代码块 内部类

• 什么是内部类：一个类嵌套在另一个类中，前者交内部类，后者交外部类

• 内部类的定义：

  • 成员内部类

    • 非静态内部类
      • 语法：【访问权限修饰符】【修饰符】class 类名{}
        • 访问权限修饰符4个：public protected 默认（package） private
        • 修饰符：static final abstract
      • 调用： 外部类名.内部类名 对象=new 外部类名().new 内部类名();
    • 静态内部类
      • 调用：外部类名.内部类名 对象=new 外部类名.内部类名();

  • 局部内部类

    • 局部内部类封装在外部类的一个方法中，此方法一般有一个返回值，返回该局部内部类类型

    public class TestInnerClass { 
    	public static void main(String[] args) { 
    		//调用非静态内部类
    		OutClass out=new OutClass();
    		OutClass.InnerClass inner=out.new InnerClass();
    		inner.show1();
    		//调用静态的内部类
    		OutClass.InnerClass1 inner1=new OutClass.InnerClass1();
    		inner1.age=10;
    		inner1.show2();
    	}
    }
    //外部类
    class OutClass{ 
    	//1.属性
    	private String name;
    	//2.方法
    	
    	public void show() { 
    // System.out.println("这是外部类方法的输出");
    		//外部类调用内部类的方法
    		 OutClass out=new OutClass();
    		 OutClass.InnerClass inner =out.new InnerClass();
    		 inner.show1();
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	//3.构造器
    	public OutClass() { 
    		
    	}
    	public OutClass(String name) { 
    		super();
    		this.name=name;
    	}
    	//4.代码块
    	{ 
    		System.out.println("这是外部类的代码块");
    	}
    	//类中的第五个成员
    	//非静态内部类
    	class InnerClass{ 
    		private String name;
    
    		public String getName() { 
    			return name;
    		}
    
    		public void setName(String name) { 
    			this.name = name;
    		}
    		public void show1() { 
    			show();   //调用外部类的方法
    		}
    	}
    	//静态内部类
    	static class InnerClass1{ 
    		int age;
    		public void show2() { 
    			System.out.println(age);
    		}
    	}
    	public void info() { 
    		//局部内部类
    		class Person{  
    			
    		}
    	}
    }