JavaSE.20190505.接口.23种设计模型(常用).内部类.Lambda表达式.

一.接口

     1.接口是特殊的抽象类
         1)接口的优点:
                              定义开发规范
                              提高代码的复用性
                              解耦
                              多实现类只能单继承
      2.在jdk1.7及之前接口中只能存在公共的静态的常量+公共的抽象方法
         1)公共的静态的常量:
             public static final 数据类型 变量名=赋值;
             修饰符可以省略,默认存在
         2)公共的抽象的方法:
            public abstract 返回值类型  方法名();
            修饰符可以省略,默认存在
         3)使用:类名.常量名 |实现类名.常量名|实现类对象.常量名
            实现类对象.方法名();
      3.注意:
        1)定义接口interface关键字
        2)抽象方法必须重写
        3)接口如何使用:
           具体的实现类去实现接口,重写里面的抽象方法 按需扩展
           抽象的实现类实现接口,重写部分抽象方法按需扩展
        4)实现和继承很像,都能使用父类或者父接口中的功能
        5)接口不能实例化
        6)类只能继承类,继承只能单继承,类可以多实现接口,一个类可以实现多个接口
        7)接口和接口之间只能继承不能实现,接口可以继承多个接口
        8)避免实现的多个接口中存在同名方法
       4. jdk1.8新增:
          1)default默认方法,是个具体的方法,只能通过实现类的对象使用
          2)静态方法,只能在当前接口中使用,不能通过实现类使用

二.23种设计模式(常用的几种)

     1.单例模式:这个类只能有一个实例
        饿汉式: 无论是否使用,在类加载的时候先创建一个对象    线程安全的  --效率低
        懒汉式: 在使用的时候才创建对象,不适用不创建              线程不安全的--效率高,通过加锁控制
     2.实现单例的步骤:
        1)私有的构造器
        2)私有的静态的该类引用
        3)公共的静态的访问方式

public class Single {
	//2.私有的静态的该类引用  存储创建的这个类的实例
	private static Single single=new Single();
	//1.私有的构造器
	private Single(){
	}
	//3.公共的静态的访问方式
	public static Single newInstance(){
		return single;
	}
}

      3.静态代理
         1)代理角色,真实角色实现相同的接口|继承相同的父类
         2)代理角色持有真是角色的引用
         3)代理行为
         静态代理优点:解耦,提高的代码的服用性,便于代码的后期维护

      4.简单工厂模式:
         1)工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
         2)抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
         3)具体产品角色：工厂类所创建的对象就是此角色的实例。在 Java 中由一个具体类实现.

三.内部类 (类中存在类,就是内部类)
     1.什么时候需要定义内部类:
        在一个类中,内部的成员又是一个其他的事物,这个成员就可以定义为内部类
            class Car{
               class 发动机{
                }
            }
      2.内部类的分类:
         1)成员内部类
         2)静态内部类
         3)私有内部类
         4)局部内部类
         5)匿名内部类 :***
       3.成员内部类:
          1)在外部类的成员位置,定义的类,叫做成员内部类
          2)即是成员也是类,既有成员的特性,能使用成员修饰符(public ,static..),既然是类就有类的特性,类之间可继承,可以实现接口
          3)内部类中可以 使用外部类中的内容,包括私有
          4)在成员内部类中只能定义静态的常量,其他静态内容不可以
          5)在外部类中通过内部类的对象使用内部类中的内容
          6)内部类编译后使用$表示
          7)在其他类中如何使用内部类中的内容:    
                            外部类  引用 = new 外 部类();
                            外部类.内部类  引用 =引用.new 内部类();
                            外部类.内部类  引用 =new 外部类().new 内部类();

public class Outer01 {
	private int a=5;
	static int b=15;
	
	//成员内部类
	class Inner implements A{
		int c=10;
		static final int d=20;
		
		//内部类中的成员方法
		public void inner(){
			System.out.println(a);
			System.out.println(b);
			System.out.println("内部类中的成员方法inner");
			
			//outer();
		}
	}
	
	//外部类中的成员方法
	public void outer(){
		System.out.println("外部类中的成员方法outer");
		System.out.println(Inner.d);
		//通过对象.调用内部类中的内容
		Inner in=new Inner();
		///in.inner();
		System.out.println(in.c);
	}
	
}

interface A{}

        4.私有的内部类:
           只能在外部类中通过私有内部类的对象使用私有内容

        5.静态内部类:
           1)只能在静态的内部类中定义静态的内容,除了静态的常量
           2)静态内部类可以定义静态的可以定义成员的  
           3)其他类中使用静态内部类中的内容:
               外部类.内部类  引用 = new 外部类.内部类();

public class StaticInner {
	private int a=10;
	private static int b=22;
	//静态内部类
	static class Inner{
		static String name="李四今天穿了一个纱裙";
		int age=20;
		/*
		 * 内部类中的静态方法中
		 * 静态的内部类中的静态方法中,可以直接使用静态内部类和外部类中的静态内容,要通过对象使用非静态的内容
		 */
		static void testStatic(){
			System.out.println("我是静态内部类中的静态方法");
			StaticInner staticInner=new StaticInner();
			System.out.println(staticInner.a);
			System.out.println(b);
			System.out.println(name);
			Inner in=new Inner();
			System.out.println(in.age);
		}
		/*
		 * 静态内部类中的成员方法
		 * 静态的内部中的成员方法中可以直接使用静态内部类中的成员,可以直接使用外部类的中的静态的内容,但是外部类中的成员内部要通过外部类对象使用
		 * 	因为静态的内部类也是静态的环境
		 */
		void test(){
			System.out.println("我是静态内部类中的成员方法");
			System.out.println(age);
			System.out.println(name);
			System.out.println(b);
			StaticInner staticInner=new StaticInner();
			System.out.println(staticInner.a); 
		}
	}
	//外部类中的成员方法
	public void outer(){
		System.out.println(Inner.name);
		Inner in=new Inner();
		System.out.println(in.age);
	}
}

       6.局部内部类:
          1)局部:{}-->作用域
          2)方法中的内部类 --> 局部内部类
          3)注意:
                 局部内部类中的内容只能在当前所有在方法中通过对象使用
                 局部内部类不能使用成员修饰符,但是final可以
           4)在局部内部类中使用当前所在方法的参数,需要把这个参数定义为final修饰,jdk1.7及之前必须显示定义final,1.8中可以省                   略final,默认存在

       7.匿名内部类:
          简化接口的实现类|子类,可以使用匿名内部类

四.Lambda表达式
     1.  jdk1.8新增
     2.目的:为了简化匿名内部类
         格式  ( )  ->  { }
          (): 抽象方法的参数列表
          ->:箭头函数,箭头符号,具有上下文推倒的作用
          {}:抽象方法的方法体  
      3.前提:函数式接口
         函数式接口:只有一个抽象方法的接口,叫做函数式接口
      4.检测是否为函数式接口: @FunctionalInterface

public class LambdaDemo05 {
	public static void main(String[] args) {
		A a=null;
		/*a=new A(){
			@Override
			public void a(int a) {
				System.out.println("我是匿名内部类的方法体实现");
			}
		};
		a.a();*/
		
		/*a=()->{System.out.println("我是Lambda的方法体实现");};
		a.a();*/
		
		/*a=(age)->{System.out.println("抽象方法存在一个参数,参数的数据类型可以省略,前后()可以省略"+age);};
		a.a(20);*/
		
		/*a=(age,height)->{System.out.println("抽象方法存在2个参数,参数的数据类型可以省略,前后的()不可以省略"+age+height);};
		a.a(20,180);*/
		
		//a=(age,height)->System.out.println("抽象方法的方法体语句只有一句,前后的{}可以省略"+age+height);
		
		//如果抽象方法有返回值,只有一条返回值语句,return和前后的{}都可以省略
		a=(age,height)-> -111 ;
		System.out.println(a.a(18,185));
	}
}

//函数式接口
@FunctionalInterface
interface A{
	int a(int age,int height);
	//void b();
}