接口

可以理解为特殊的抽象类

关键字interface -->接口

接口的优点

1. 接口是功能体的集合
2. 是一个引用数据类型
3. 能够解耦
4. 规定开发规范

jdk在1.7之前

属性:

必须是公共的静态的常量 public static final

public staic final 可以选择性省略(默认)

方法:必须是公共的抽象的方法

public abstract 返回值类型 方法名();

public absract 可以选择性省略

注意:

1. 接口的实现与类的继承非常像,但是不一样在:
   1. 子类继承父类就可以直接使用父类的内容
   2. 实现类实现接口,也拥有接口中的能力,但是需要实现列自己去实现这个功能
   3. 接口实现的关键字是implement,继承的关键字是extends
2. 类只能单继承,接口可以多实现,一个类需要继承父类后实现接口.
   1. 如果先接口后继承,会造成系统无法判断接口的个数.
3. 接口也不能实例化
4. 接口的使用只能通过类去实现接口
   1. 具体的实现类:重写了所有的抽象方法+按需新增
   2. 抽象类的实现:按需重写了抽象方法+按需新增,具体的子类才能使用
      1. 在抽象类中,可以全部实现,也可以部分实现

      //抽象实现类

      abstract class Demo02 implements InterfaceDemo02{

      //  @Override

      //  public void demo2() {

      //      // TODO Auto-generated method stub

      //

      //  }

      }

5. 继承和实现的几种情况
   1. 接口和接口之间是可以继承的
   2. 类和接口之间只能实现
   3. 接口之间可以多继承
   4. 类和接口之间可以多实现

//定义一个接口InterfaceDemo02

interface InterfaceDemo02{

    public void demo1();

}

//定义一个接口InterfaceDemo03

interface InterfaceDemo03{

    public void demo2();

}

//定义一个接口InterfaceDemo04 并继承InterfaceDemo02及InterfaceDemo03

interface InterfaceDemo04 extends InterfaceDemo02,InterfaceDemo03{

}

实现了接口

public class Demo implements InterfaceDemo02, InterfaceDemo03 {//与只实现InterfaceDemo04作用相同

    @Override

    public void demo2() {

        System.out.println("实现了接口02");

    }

    @Override

    public void demo1() {

        System.err.println("实现了接口03");

    }

}

jdk1.8中新增的内容

在接口中可以定义方法体的方法

1. 默认方法:default关键字修饰(必须是显式的)
   1. 使用:通过实现类使用
2. 静态方法
   1. 使用:接口名使用

public interface InterfaceDemo05 {

    //默认方法

    public default void moren(){

        System.out.println("我是默认方法");

    }

    //静态方法

    public static  void test(){

        System.out.println("我是静态方法");

    }

}

//实现类

class Impl implements InterfaceDemo05{

}

测试

public class Test {

    public static void main(String[] args) {

        //默认方法通过类实现

        Impl i=new Impl();

        i.moren();

        //静态方法通过接口名.方法调用

        InterfaceDemo05.test();

    }

}

设计模型

单例模式

保证一个类只能有一个对象,这个特点形式的类成为单例模式,但是不影响类中原有功能.

实现

1. 构造器私有化
2. 私有的 静态的该类引用,存储创建唯一的对象
3. 公共的 静态方法方式

两种方式

饿汉式

当第一次调用的时候才创建这个实例 ---线程不安全,效率较高

示例

//饿汉式

public class SingTon {

//1.构造器私有化

    private SingTon(){

    }

//2.私有的,静态的该类的引用,存储创建唯一的对象

    //在类的第一次加载时候,创建一个唯一的实例

    private static SingTon single=new SingTon();

?

//3.公共的 静态的方法方式

//返回值:当前数据类型  参数:没有

    private static SingTon newInstance(){

        //将当前创建的实例返回出去

        return single;

    }

}

懒汉式

在类的第一次加载完成之后,就创建这个实例 ---线程安全,效率较低

示例

//懒汉式

public class Single {

    //1.私有的构造函数

    private Single(){

    }

    //2.私有的 静态的 该类的引用,存储创建唯一的对象

    //先创建一个对象的默认参数为null

    private static Single single=null;

    //3.公共的静态的该类的引用

    public static Single newInstance(){

        //先判断实例是不是为空,如果为空则新建

        //如果不为空则返回上一次对象的地址

        if(single==null){

            Single single=new Single();

        }

            return single;

        }

}

代理模式

静态代理:

1. 真实角色和代理角色实现相同的接口|继承相同的父类
2. 代理角色持有真实角色的引用:成员属性进行维护
3. 代理行为

注意:减少与真实角色的交流,降低耦合度,起到功能的扩展,方便后期维护

/*经理要通过人事招人,相当于  技术部经理 找了 人事当代理

真实角色:经理

代理:人事  

行为:招人(人事和经理都需要实现)

代理模式就是把真实角色作为代理角色的一个成员变量

*/

public class StaticProxy {

    public static void main(String[] args) {

    }

}

//经理

class Manager implements Hiring{

    @Override

    public void hiring() {

        System.out.println("我是经理,我要招人");

    }

}

//人事

class Hr implements Hiring{

    Manager manager;

    //完全可以通过构造函数把真实角色引入到这个代理角色中

    public Hr(Manager manager) {

        super();

        this.manager = manager;

    }

    @Override

    public void hiring() {

        System.out.println("我是人事,我要初试");

        //重头戏 把真实角色当成代理模式的一个成员

        this.manager.hiring();

        System.out.println("成功录取");

    }

}

//行为:招人

interface Hiring{

    void hiring();

}

//测试

class Test{

    public static void main(String[] args) {

        Manager m=new Manager();

        Hr h=new Hr(m);

        h.hiring();

    }

?

}

工厂模式

/*

 *需求:我们直接从工厂拿车,如果是两轮输出两轮

 *      四轮输出四轮 

 * 

 */

public class Factory {

?

    public static void main(String[] args) {

        Car two=new TwoCar();

        Car four=new FourCar();

        Factory f=new Factory();

        two.make();

        f.factory(two);

        two.run();

        four.make();

        f.factory(four);

        four.run();

    }

    /*

     有一家工厂可以造两个轮子也可以造四个轮子

    一工厂是可以生产车的,这个是一个功能(方法)

    结果:确定这个是方法

    二工厂是可以生产不同的车的,可以创建不同的对象

    结果:确定方法体的内容

    三工厂无论生产哪种类型的车都是车,所以返回值一定是车

    结果:确定返回值类型

    四工厂生产车,需要给输入值

    结果:确定参数

    */

    //看传入的是否是 TwoCar或ForCar的一个实例

    public static Car factory(Car srt){

        if(srt instanceof TwoCar){

            System.out.println("在造两轮");

        }

        if(srt instanceof FourCar){

            System.out.println("在造四轮");

        }

            return srt;

    }

}

interface Car{

    void make();

    void run();

}

class TwoCar implements Car{

?

    @Override

    public void make() {

        System.out.println("我是造两轮的模板");

    }

?

    @Override

    public void run() {

        System.out.println("乌龟");

    }

}

class FourCar implements Car{

?

    @Override

    public void make() {

        System.out.println("我是造四轮的模板");

    }

?

    @Override

    public void run() {

        System.out.println("飞一样的感觉");

    }

}

内部类

1. 成员内部类
2. 静态内部类
3. 私有内部类
4. 局部内部类
5. 匿名内部类

成员内部类

当内部类作为外部类的成员,就是成员内部类

外部成员----------内部类

特点:

1. 是成员就具有成员的特点,就是可以使用成员修饰符修饰
2. 是类就有类的特点,可以继承及实现
3. 内部类可以使用外部列的内容,包括私有的
4. 在外部类中可以通过内部类的对象使用其成员
5. 成员内部类中不能定义静态内容除了静态常量

私有内部类

1. 私有内部类可以使用外部类中的私有内容
2. 外部类中可以使用私有内部了中的私有内容,需要通过内部类对象使用
3. 私有的内部类中只能在外部类中使用,其他类中无法使用

静态内部类

1. 只有静态内部类中可以定义静态的内容,除了静态的内容
2. 静态内部类中使用外部类中的成员,通过外部类对象使用,因为内部类是静态

局部内部类

1. 方法中的内部列
2. 不能使用成员修饰符 public static(final可以)
3. 局部只能在它当前定义的方法中使用,通过对象使用
4. 如果想要在局部内部类中使用当前方法的参数,这个参数必须被final修饰,在jdk1.8中final可以省略,但是默认

匿名内部类

1. 匿名内部类
2. 匿名对象的内部类
3. 方法的参数

原文地址：https://www.cnblogs.com/wuzhaoming/p/11741231.html