面向==对象==

OO: Oritened Object

OOP： 使用oo的思想进行开发。 利用对象实现功能。
    面向对象编程。 
1. 封装
2. 继承
3. 多态    

面向过程 c   vs  面向对象:
面向过程：
    线性的执行功能。一步一步执行功能。 顺序执行。
    人要睡觉:
       先去刷牙 洗脸  上厕所  脱衣服
面向对象:
     人对象.睡觉();
面向对象的开发: 
     里面嵌套面向过程。

1. 类与对象

目的: 创建对象。

在生活中:
  对象:
    假设有女朋友---> 真实存在实体，个例      
    物以类聚:   先有个体  再有类别  一个个学生  就组成学生类
        
在程序:
  先有类别(class):
     创建个体(对象)。   女娲造人 / 盖房子 
class:
   利用很多实体(对象)---> 抽象出来的模板。---> 维护所有的对象共有一些内容。
一个类----> 很多个对象
每一个对象---->一个类对应。       

1.1 创建类

引用类型 null

语法:
public class 类名{//大写驼峰
     //main
     //方法
     //全局变量
}

public class Student {
​
    //所有学生对象共有一些信息
    //1.成员变量(全局变量,属性)
    //int num = 100;
    //[访问权限修饰符] [普通修饰符] 数据类型 变量名称[= 数据];
    //对于成员变量而言 如果不赋值 获得类型的默认数据
    public int id;
    public String name;//null
    public int age;
    public char gender;
    public double score;//0.0
    public String[] hobby;//null
​
    //2. 成员方法(功能)
    public void study() {
        System.out.println(name + "在学习。。。。");
   }
    
}
​

==1.2 创建对象==

语法: ==类名 对象名/变量 = new 构造方法;== 数据类型 变量名 =

Scanner input = new Scanner();
// 在测试类里面测试对象的创建   StudentTest.java   测试环境下 test包
 Student liTao = new Student();
1. 开辟内存空间
2. 初始化成员变量数据
3. 赋值    

==1.3 使用对象==

对象可以调用类的成员。 ==对象名.属性; 对象名.方法名();==

public static void main(String[] args) {
​
        //创建Student类的对象
        //类名 对象名/变量 = new 类名();
        Student liTao = new Student();//liTao 对象 堆内存
        System.out.println(liTao);//com.javasm.obj.Student@4554617c 哈希code
​
        //OOP
        //访问属性
        //赋值
        liTao.id = 1001;
        liTao.name = "李涛";
        liTao.age = 20;
//       liTao.gender = 'M';
//       liTao.score = 100;
//       String[] hobby1 = {"code","music","game"};
//       liTao.hobby = hobby1;
​
        System.out.println(liTao.id);
        System.out.println(liTao.name);
        System.out.println(liTao.age);
        System.out.println(liTao.gender);
        System.out.println(liTao.score);
        System.out.println(Arrays.toString(liTao.hobby));
​
        //访问方法
        liTao.study();
​
   }

1.4 对象内存

public static void main(String[] args) {
​
        Student student = new Student(); //强引用
​
        student.name = "张三";
        System.out.println(student.name);
        student.study();
​
​
        System.out.println("-------------------");
        Student student1 = new Student();
        //jvm运行期间: 内存--->运行数据区
        //class在jvm里面有且只有1份 只加载一次
​
        System.out.println(student1.name);
        student1.study();
​
​
        System.out.println(student == student1);//false
        System.out.println(student.equals(student1));//false
​
        //方法结束: 栈内存的数据全部清除(栈内存永远够用)
        //堆内存/元空间?(内存溢出)
        //GC--->回收无用对象---> 引用
        //元空间里面: 一个class文件---> Class类对象与之对应。
   }

==1.5 构造方法==

public static void main(String[] args) {

        //new UserInfo() 创建对象(开辟内存) 初始化

        UserInfo userInfo = new UserInfo();
        //()  肯定是方法
        System.out.println(userInfo);
        System.out.println(userInfo.id);
        System.out.println(userInfo.name);
        System.out.println(userInfo.pass);

        System.out.println("----------------------");
        UserInfo userInfo1 = new UserInfo();
        System.out.println(userInfo1.id);
        System.out.println(userInfo1.name);
        System.out.println(userInfo1.pass);

        System.out.println("==============================");


        UserInfo userInfo2 = new UserInfo("张三", "2021-01-01", '男');
        System.out.println(userInfo2.birthday);
        System.out.println(userInfo2.gender);
        System.out.println(userInfo2.name);
    }

public class UserInfo {


    public int id;
    public String name;
    public String pass;
    public String birthday;
    public char gender;
    public int age;


    //方法.....

    //构造方法
    //[访问权限修饰符] 类名(){}
    //方法名与类名是一致的
    //默认存在

    //无参构造方法(每个类里面默认存在一个无参的构造方法)
   /* public UserInfo() {
        System.out.println("UserInfo无参构造，，，，初始化成员变量的数据");
//        id = 1001;
//        name = "admin";
//        pass = "1234";
    }

    //构造方法重载
    public UserInfo(String name1, String birthday1, char gender1) {

        //赋值给成员变量
        name = name1;
        birthday = birthday1;
        gender = gender1;

    }
*/
    //一个类里面: 没有显示无参构造   有参就会覆盖无参构造

    //利用工具IDEA生成构造方法  alt+insert


    public UserInfo() {
    }

    public UserInfo(int id, String name, String pass, String birthday, char gender, int age) {
        this.id = id;
        this.name = name;
        this.pass = pass;
        this.birthday = birthday;
        this.gender = gender;
        this.age = age;
    }

    public UserInfo(String name, String pass, String birthday, char gender) {
        this.name = name;
        this.pass = pass;
        this.birthday = birthday;
        this.gender = gender;
    }


    public UserInfo(String name, String pass, char gender) {
        this.name = name;
        this.pass = pass;
        this.gender = gender;
    }
}

1.6 成员变量 vs 局部变量

1.7 案例

习题

==1.8 对象数组==

数据类型[] 数组名称 = new 数据类型[length];
public static void main(String[] args) {

        //创建数组  维护多个车对象
        Car[] carArray = new Car[10];
        carArray[0] = new Car("a1", 4, "a");
        carArray[1] = new Car("a2", 4, "a");
        carArray[2] = new Car("a3", 4, "a");
        carArray[3] = new Car("a4", 4, "a");
        carArray[4] = new Car("a5", 4, "a");

        //循环遍历获得车品牌名称
        int length = carArray.length;
        for (int i = 0; i < length; i++) {
            Car car = carArray[i];
            if (car == null) {
                break;
            }
            System.out.println(car.brandName);
        }

        System.out.println("---------------------------------");
        for (Car car : carArray) {
            if (car == null) {
                break;
            }
            System.out.println(car.brandName);
        }
   }

2. 封装

封装数据/功能实现。 ==成员变量/方法==

作用: 限制对数据的访问。 该隐藏隐藏 该暴露暴露

==2.1 封装实现==

1. 使用private修饰属性或者方法
2. 提供入口:  public set/get    
3. 在方法里面进行数据校验    不推荐set/get编写功能  增加排查问题的难度
    
封装属性:
   满足生活中的规则，对于一些信息或者数据  该隐藏隐藏  该暴露暴露。
   因为封装，它是满足人的正常思维的规范。人的隐私
封装方法:
   一些核心功能 类似于安全性级别较高的核心功能  可以进行封装。
   或者一些通用的方法  也可以封装  方便程序  多次使用           

public class UserInfo {

    //数据的封装
    private int id;
    private String name;
    private String pass;
    private int age;

    //public 修饰的set/get----> 遵循规则
    //利用工具生成  alt+insert


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //数据校验处理
        if (age < 16 || age > 50) {
            System.out.println("年龄不合法");
            return;
        }
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPass() {
        //功能
        return pass;
    }

    public void setPass(String pass) {
        this.pass = pass;
    }


    //功能的封装: 多次调用
    private void getMoney() {
        System.out.println("取钱。。。。。" + name);
    }

    public void login() {
        //录入密码
        getMoney();
    }
}

//不推荐set/get编写功能  怎么校验数据?
//数据从哪里来的? 用户在客户端(用户看的到东西)提交过来。
//页面执行校验+后端加校验(实体校验)+业务层判断+数据库约束

//开发中,不在set里面写逻辑  一般在类也不写set/get

2.1 访问权限修饰符

2.2 lombok

第三方的组件。 80%+

使用注解简化类的编写。注解替换set/get/构造....
注解:
  @Setter
  @Getter
  @NoArgsConstrauctor
  @AllArgsConstrauctor
  @NonNull 实体校验
  @ToString
  @EqualsAndHashCode    
  @Data==>  @Setter  @Getter @NoArgsConstrauctor @ToString @EqualsAndHashCode
   ....    

项目开发:
  1. 配置方式开发
      在配置文件里面配置:SSM  3个配置文件: 统一维护  有问题直接找配置文件(便于定位问题)  开发效率慢
 
  2. 注解方式开发  @解释名称
      只需要在类上，方法，属性，形参 加上一个注解 配置完成了  效率很快             

1. 下载lombok https://projectlombok.org/download   jar(class文件)
2. 在项目中创建lib目录 把jar放到lib目录中
3. 将jar放到编译路径下   jvm加载class    add as a library--->project library
4. IDEA默认没有开启注解处理器的  开启注解处理器    
5. lombok集成IDEA  安装lombok插件 重启IDEA  (在class里面展示出来方法)

 每一个注解都有使用的范围:  source(java代码) class(字节码文件) runtime(运行)
     

2.3 this

this是指当前正在运行的对象。 栈内存。

1. ==this 可以访问类的成员变量/方法==

public class Book {

    private int id;
    private String name;


    public int getId() {
        return id;
    }

    //形参与成员变量 重名了
    public void setId(int id) {
        //就近原则  哪一个对象调用方法  this就是这个对象
//        System.out.println("this:" + this);
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void a() {
        //存在一个隐含的this
        System.out.println("a....this:" + this);
//        System.out.println(this.id);
//        System.out.println(this.name);

        System.out.println(this.getId());
        System.out.println(getName());

    }

2. this可以访问本类的构造方法 this();

 public Book() {
        //调用了本类的有参构造
        //this(1001,"mysql");
  }

public Book(int id, String name) {
    this();
    this.id = id;
    this.name = name;
}

3. this可以充当实际参数和返回的数据。

public class Car {

    private int wheelNum;
    private String color;
    @NonNull
    private String brand;
    //属性


    public void run() {

        if (this.wheelNum < 4) {
            //维修
            FixCarFactory factory = new FixCarFactory();
            //this充当实际参数
            factory.fixCar(this);
        }

        System.out.println(brand + "正在跑。。。。。");
    }
}

 public void fixCar(@NonNull Car car1) {
        System.out.println(name + "正在修理" + car1.getBrand() + "," + car1.getColor());
        //修理成功  ???
        System.out.println("轮子数修改为4");
        car1.setWheelNum(4);
    }

4. this 充当返回值数据

//this充当返回值--->
// 其实引用类型作为参数传递  传输的就是内存地址 任何数据的改变都会映射到原对象上
// 只是让这个概念变得更清晰 可以使用 return this;进行强调
//比如StringBuilder.append();
StringBuilder builder = new StringBuilder("hello");
builder.append(",world");
System.out.println(builder);

==2.4 static==

静态的。修饰符。

1. ==修饰成员变量/方法 —> 静态变量/方法 / 类变量/类方法== 所属: Class

public class StaticDemo {

    //一个类中 很多成员都是static修饰的  这个类必然是工具类
    //工具类构造都是private
    //public/private static final 

    //成员变量
    public int num = 10;
    private String str;

    //静态变量
    public static int num1 = 100;
    private static int num2 = 200;
    protected static int num3 = 300;
    static int num4 = 400;

    //成员方法
    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    //普通方法: 可以访问静态成员
    public void a() {
        System.out.println("a.........." + this.str);
        System.out.println(this.num);
        System.out.println(StaticDemo.num1);
        System.out.println(num2);
        System.out.println(num3);

        StaticDemo.bStatic();
    }

    //静态方法: 不能直接访问非static的成员  不能使用this
    public static void bStatic() {
        System.out.println("bStatic..........");
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        b();
    }
    
    public static void b(){}
}

2. static修饰代码块—> 静态代码块

普通代码块: {}
静态代码块:
 static{}

@Setter
@Getter
public class Animal {

    private String name;

    public Animal() {
        System.out.println("3Animal.....无参构造");
    }

    {
        System.out.println("2普通代码块");
    }


    static {
        System.out.println("1static代码块  只被加载一次");
        //初始化静态变量的数据
    }
}

1static代码块
2普通代码块
3Animal.....无参构造
---------------------
2普通代码块
3Animal.....无参构造

public class Animal {

    public static Animal instance;

    private Animal() {
        System.out.println("3Animal.....无参构造");
    }

    static {
        // System.out.println("1static代码块  只被加载一次");
        //初始化静态变量的数据
        instance = new Animal();
    }
}

3. static 修饰类—–> 内部类

在类的内部:
   1. 成员内部类
       1.1 静态内部类
       1.2 非静态内部类
       
   2. 方法内部类
   3. 匿名内部类     

@Setter
@Getter
public class MyClass {

    private int num;

    //成员内部类
    //1.1 静态的内部类
    public static class StaticChildClass {

        //成员变量/方法
        public int a = 200;

        public void b() {
            System.out.println("b....." + a);
        }

        public static void c() {
            System.out.println("c.............");
        }

    }

    public class NonStaticChildClass {
        public int b = 300;

        public void c() {
            System.out.println("c....." + b);
        }
    }

    public int demo() {
        class A {
            private int aaa() {
                return 10 * 100;
            }
        }
        return new A().aaa();
    }

}

 public static void main(String[] args) {

        //目的: 访问StaticChildClass成员
//        MyClass myClass = new MyClass();
//        System.out.println(myClass.getNum());
//
//
//        MyClass.StaticChildClass staticChildClass = new MyClass.StaticChildClass();
//
//        System.out.println(staticChildClass.a);
//        staticChildClass.b();
//
//        MyClass.StaticChildClass.c();


//        MyClass.NonStaticChildClass nonStaticChildClass = new MyClass().new NonStaticChildClass();
//
//        System.out.println(nonStaticChildClass.b);
//        nonStaticChildClass.c();

        System.out.println(new MyClass().demo());
    }

==3. 继承extends==

封装: 安全。限制对数据访问。
继承: 提高了程序/代码复用性。
多态: 提高了程序的可扩展性。    

语法:
  体现在类与类之间。层级关系。  父与子关系。
public class ChildClass  extends ParentClass{
    
}  
public class ParentClass extend GrandPaClass{
    
}
ChildClass: 子类(派生类) 继承了 父类(基类)的成员. (排除private修饰成员  以及 父类的构造方法)  
    子类也 可以有独有的成员变量和方法。
java里面继承属于单根继承。一个类只能继承一个类。    
所有的类都默认继承超级父类Object  。    

3.1 案例

马戏团的案例。

很多小动物开始进行表演。
 Monkey.java
 Elephant.java
 Linon.java
 Tiger.java        

父类

public class Animal /*extends Object*/{
    private int id;
    private String name;
    private int age;


    public void show() {
        System.out.println(name + "在表演。。。。");
    }

    public Animal() {
    }

    public Animal(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

子类 :

public class Monkey extends Animal {
    public Monkey() {
    }
}

@Setter
@Getter
public class Lion extends Animal {

    private int num;
    //Lion子类独有的方法
    public void leader() {
        System.out.println(this.getName() + "有领导能力。。。");
    }
}

public class Tiger extends Animal {
}

测试

public class Manager {

    //管理小动物  让小动物表演
    //发布表演命令
    public void showOrder(@NonNull Lion lion) {

        lion.show();
    }

    public void showOrder(@NonNull Monkey monkey) {

        monkey.show();
    }


}

3.2 创建子类对象

1. 默认执行父类的构造
2. 执行子类的构造   
    
Employee....静态的代码块
SE....静态的代码块
Employee....无参构造
se.....无参构造。。。。
se:com.javasm.obj1.SE@1540e19d
------------------
Employee....无参构造
se.....无参构造。。。。

创建子类对象默认调用了父类的构造，有没有创建父类对象?  没有创建父类对象。   

3.3 有参创建子类对象

 //所有的子类的构造方法 都会默认调用父类的无参构造
    public SE(int id, String name, char gender, double salary, int hot) {
        super();
        this.hot = hot;
        this.setId(id);
        setName(name);
        setGender(gender);
        setSalary(salary);
    }

把父类的无参构造删除了，会出现问题?

//在子类无参里面  调用父类的有参  没有意义的
//在以后的代码里面 几乎不存在子类无参调用父类的有参
//子类的有参也不会调用父类的无参
//不会混合使用

/* public SE() {
        //默认调用了父类的无参构造 super()
        super();
        System.out.println("se.....无参构造。。。。this:" + this);
    }

    //所有的子类的构造方法 都会默认调用父类的无参构造
    //子类构造方法中  必须调用一个父类的构造
    public SE(int id, String name, char gender, double salary, int hot) {
        super(id, name, gender, salary);
        this.hot = hot;
    }*/

    //利用工具完成
    public SE() {
        super();
    }

    public SE(int id, String name, char gender, double salary, int hot) {
        super(id, name, gender, salary);
        this.hot = hot;
    }

3.4 super

this VS super
super不是一个对象  只是父类的引用
1. 在子类中  super访问父类成员变量和方法    
2. 在子类的构造中  利用super 调用父类构造方法   

//父类
public class Parent {
    public int num = 100;
    public static int a = 10000;
    public void a() {
        System.out.println("Parent............a....");
    }
    public Parent() {
    }
}

public class Child extends Parent {
    private int num1 = 1000;
    public Child() {
        super();
    }
    public void demo() {
//        System.out.println(this.num);//300
        System.out.println(super.num);
        System.out.println(this.num);
        System.out.println(a);
    }
    public static void main(String[] args) {
        Child child = new Child();
        child.num = 200;
        child.demo();
    }
}

3.5 方法重写 @override

方法重载:  (工具类)
  1. 方法名必须相同
  2. 形参必须不同
  3. 与返回值和修饰符无关          

前提: 
  有层级关系。 继承  实现
//子类重写父类的方法     
 1. 子类重写方法名，形参必须与父类的方法相同的
 2. 子类重写返回值类型<=父类方法的返回值 
 3. 子类重写访问权限修饰符>=父类方法访问权限修饰符     public protected 默认 private 

public Animal a() {
        System.out.println("Parent............a....");
        return null;
    }
@Override
public Monkey a() {
    return null;
}

但是，不推荐在子类中重写父类的方法。 里式替换原则

在面向对象编程的设计中:  
   SOLID:
      s: 单一功能原则
      O: 开放闭合原则
      L: 里式替换原则
      I: 接口隔离原则
      D: 依赖注入原则            
          
里式替换原则:
    1. 父类出现的地方  都可以使用子类替换
    2. 不要更改父类的结构    ---> 抽象方法/接口(推荐)

4. 多态

作用: 提高程序的可扩展性。

多态:
  多种状态。----> 对象有多种状态。
      
  一个对象具备多种状态的能力  这个程序就是可扩展的。
      
前提:
   必须有层级关系。 继承  实现
       
继承:  子类和父类的关系。   一个父类可以有多个子类。  --->    父类的引用有多种形态。     

4.1 案例:动物表演

 //使用多态的方式  实现  animal--->多态了  子类对象向上转型
    // 提高了showOrder的可扩展性
    //1. 形参
    //2. 返回值
    //3. 创建对象
    //Animal animal = monkey;
    //Animal animal = new Monkey(1, "吉吉国王", 3);
    // 1.子类对象向上转型父类的引用
    //数据类型转换: 自动转换
    //2. 父类的引用指向了任意的一个子类的对象
    //3. 编译时数据类型(=左边的类型)与运行时的数据类型(=右边的类型)不一致的时候


    public static void showOrder(@NonNull Animal animal) {
        System.out.println("animal:" + animal);
        animal.show();
        //在多态 的环境下 :  调用属性--->看父类  调用方法---> 看子类
    }

 public static void main(String[] args) {

        Monkey monkey = new Monkey(1, "吉吉国王", 3);

        System.out.println("monkey:" + monkey);
        Manager.showOrder(monkey);

        System.out.println("--------------------------------");

        Lion lion = new Lion(2, "辛巴", 3, 200);
        System.out.println("lion:" + lion);
        Manager.showOrder(lion);

    }

4.2 案例: 发工资

public class CalSalaryUtil {

    private CalSalaryUtil() {
    }
    //1. 多态: 子类对象向上转型 ---> 弊端: 无法访问子类的独有的成员
   //Employee employee = new PM();  JVM优先查询编译时数据类型的class
    public static double calSal(@NonNull Employee employee) {

        //获得pm的奖金: bonus: 子类独有的成员
        //调用属性: 看父类
        //调用方法： 看子类

        //如何获得子类的独有成员?  employee子类对象
        //父类引用的向下转型(高转低)

        double salary = employee.getSalary();

        //有条件的执行的： instanceof 判断一个引用是否是一个类的实例
        if (employee instanceof PM) {
            PM pm = (PM) employee;
            salary += pm.getBonus();
        } else if (employee instanceof Sale) {
            Sale sale = (Sale) employee;
            salary += sale.getTiCheng();
        }

        return salary;
    }

    //完全使用重载替换。

}

// 向下转型的时候  一定要加instanceof进行判断  否则有可能会出现ClassCastException
Exception in thread "main" java.lang.ClassCastException: com.javasm.obj1.SE cannot be cast to com.javasm.obj1.PM
	at com.javasm.obj1.CalSalaryUtil.calSal(CalSalaryUtil.java:31)
	at com.javasm.obj1.Test.main(Test.java:20)

4.3 案例: 返回值

与方法重写。

public class Parent {

    public Parent info() {
        System.out.println("Parent.info.....");
        return null;
    }
}


class Child extends Parent {

    //子类重写父类的info方法
    @Override
    public Child info(){
        return new Child();
    }
}

4.4 案例: 创建对象

 //多态的方式创建对象
Employee employee1 = new SE(1, "se", 'm', 6000, 100);
CalSalaryUtil.calSal(employee1);

//对象数组---> 维护所有的员工信息
//数据类型[]  数组名= new 数据类型[10];
Employee[] array = new Employee[10];
array[0] = pm;
array[1] = se;
array[2] = sale;

//查看所有的员工的姓名
for (Employee employee : array) {
    if (employee == null) {
        break;
    }
    System.out.println(employee.getName());
}

4.5 多态总结

多态:
  其实就是子类对象向上转型.
  也可以说是父类引用指向任意一个子类对象。
  也可以说是编译时类型与运行时类型不一致的时候。
         
优势:
  扩展程序，减少代码冗余。提升功能可扩展性。
      
弊端：
  继承关系下的多态: 无法访问子类的独有成员。(因为jvm查看的是编译时数据类型class)
  在多态环境下 如果要获得子类独有成员 需要将父类引用向下转型成子类对象 。
  一定要使用  instanceof 进行判断  避免出现类型转换的异常。
      人---> 男人 女人   男人是人  女人也是人  但是人不一定就是男人或者女人，一定要加判断。
      
在多态下，记住一句话: 调用属性 看父类    调用方法  看子类(因为子类有可能会重写父类的功能) 
    
多态只是一种方式，如果多态功能里面代码相对繁琐，判断比较多的话，也可以选择其他方式，比如: 方法重载。    

5. 抽象类

继承关系。 抽象类作为父类存在 的。

public abstract class AClass{
    //属性和 方法。抽象方法
    //构造
}

所有的子类都要重写父类的抽象方法。    
1. 抽象类不能直接创建对象的(虽然有构造。) 
    服务于子类对象创建
    服务于多态
    
    
2.组成部分就比普通类多了一个抽象方法。抽象类可以没有抽象方法   但是有抽象方法的类肯定是抽象类。   

5.1 匿名内部类

        //内部类: 1. 匿名内部类   2. 方法内部类  3. 成员内部类

        //使用抽象类创建匿名内部类==> 等同于创建了一个子类(子类没有名字 匿名的内部类)
        //匿名的内部类对象
        MyAbstractClass myAbstractClass1 = new MyAbstractClass() {
            public double num1 = 100;

            @Override
            protected String abs(int num) {
                abc();
                return "abc";
            }

            private void abc() {
                System.out.println("abc...............");
            }
        };

        System.out.println(myAbstractClass1.abs(10));
        //调用abc/num 多态: 无法访问子类的独有成员
        
        MyChild myChild1 = new MyChild(){
            @Override
            public void demo() {
                super.demo();
            }
        };

        myChild1.demo();

==6. 接口 interface==

class  interface   enum   annatation  +资源文件(配置文件)+jar   
public interface 接口名称{
    //与类名规范一样
}  

类与类单继承关系 。 利用接口进行弥补。

    
在工作中 接口命名只有2种:
   ***Dao/DAO.java
   ***Service.java
       
 接口的实现类的命名方式2种:
       ***DaoImpl/DAOImpl.java   
       ***ServiceImpl.java
用户: UserInfoDao.java              
页面(视图层)--->服务器---> 控制层(servlet SpringMVC)---->
    service(业务逻辑处理)---->dao(数据持久层)---->DB(数据库)  

在生活中,接口:
   DELL--->USB接口----> 设备
 制定规则  制定规范。

6.1 组成部分

1. jdk1.8-

public interface MyInterface {//制定规则

    //接口里面的 组成部分全部都是public

    //1. 常量 [public static final]  必须初始化  且值不允许更改  常量的名称全部都是大写
    int ID = 100;
    String USERNAME = "ADMIN";
    String PASSWORD = "1234";

    //2.方法jdk1.8- 接口里面的方法 全部都是abstract  [public abstract]

    void a();

    int max(int num1, int num2);
}

2. jdk1.8+

public interface MyInterface_1_8 {

    //常量
    String STR = "AAA";

    //抽象方法
    String test();


    //接口的新特性: 与抽象类相似
    default void a() {
        System.out.println("MyInterface_1_8......a.....");
    }

    static int b() {
        System.out.println("MyInterface_1_8......b.....");
        return 100;
    }
}

public class MyInterface_1_8Impl extends Object implements MyInterface_1_8 {
    @Override
    public String test() {
        //this.a();  可以获得接口里面的功能方法
        MyInterface_1_8.b();
        System.out.println("MyInterface_1_8Impl。。。。。test......" + STR);
        return "hello";
    }

    @Override
    public void a() {
        //调用父接口的a()
        MyInterface_1_8.super.a();
        System.out.println("MyInterface_1_8Impl重写的父接口的a.....");
    }
}

6.2 使用接口

1. 接口与类的关系: 多实现的关系 类可以实现多个接口 接口的实现类 ==implements==

一个接口可以有多个实现类

public class MyInterfaceImpl extends Object implements MyInterface,AInterface {
    @Override
    public void a() {
        System.out.println("a.......");
    }

    @Override
    public int max(int num1, int num2) {
        return Math.max(num1, num2);
    }

    @Override
    public void abc() {
        System.out.println("MyInterfaceImpl....abc.....");
    }
}

public class MyInterfaceImpl2 implements MyInterface {
    @Override
    public void a() {
        System.out.println("MyInterfaceImpl2.....a.....");
    }

    @Override
    public int max(int num1, int num2) {
        System.out.println(num1);
        System.out.println(num2);
        return 1000;
    }
}

2. 接口与接口 多继承。 extends

public interface MyInterface extends AInterface,BInterface{}

6.3 接口多态

public static void main(String[] args) {
        //普通方式创建对象
        MyInterface_1_8Impl myInterface18 = new MyInterface_1_8Impl();

        myInterface18.test();

        myInterface18.a();
        myInterface18.abc();

        System.out.println("--------------------------------");
        //多态的方式创建对象  父接口的引用指向任意一个实现类对象
        MyInterface_1_8 myInterface_1_8 = new MyInterface_1_8Impl();
//        myInterface_1_8.test();
//        myInterface_1_8.a();
        if(myInterface_1_8 instanceof  MyInterface_1_8Impl){
            ((MyInterface_1_8Impl) myInterface_1_8).abc();
        }
    }

6.4 函数式接口

@FunctionaInterface

1. 使用lamda ====> 无参无返回值

//代表接口里面 有且只有一个抽象方法
@FunctionalInterface
public interface DemoInterface {
    String S = "aaaa";

    void a();
}

 public static void main(String[] args) {

        //抽象类 new  ===> 等同于创建了一个子类  匿名内部类
        //接口   new===>等同于创建了接口的实现类  匿名内部类

        //jdk1.8+ 接口里面有且只有1个抽象方法  推荐使用lamda替换接口匿名内部类
        DemoInterface demoInterface = new DemoInterface() {
            @Override
            public void a() {

                System.out.println("a.....");
            }
        };
        demoInterface.a();

        //lamda 1.8+ 新的语法  替换重写接口里面的方法
        // (形参类型 变量1,形参类型 变量1)->{//功能}

        DemoInterface demoInterface1 = () -> {
            System.out.println("a.....lamda......");
        };
        demoInterface1.a();

    }

2. 有参无返回值

@FunctionalInterface
public interface DemoInterface {

    String S = "aaaa";

    void a(String str);
}

public static void main(String[] args) {

        DemoInterface demoInterface = new DemoInterface() {
            @Override
            public void a(String str) {
                System.out.println("str...." + str);
            }
        };
        demoInterface.a("hello");
        System.out.println("----------------------");

//        DemoInterface demoInterface1 = (String a) -> {
//            System.out.println("str...." + a);
//        };
        DemoInterface demoInterface1 = a -> {
            System.out.println("str...." + a);
        };

        demoInterface1.a("hello");
    }
}

3. 无参有返回值

@FunctionalInterface
public interface DemoInterface {

    String S = "aaaa";

    String a();
}

public static void main(String[] args) {


        DemoInterface demoInterface = new DemoInterface() {
            @Override
            public String a() {
                return "dhdgs";
            }
        };

        DemoInterface demoInterface1 = () -> {
            return "abc";
        };

        DemoInterface demoInterface2 = () -> "abc";

        System.out.println(demoInterface2.a());

    }

4. 有参有返回值

@FunctionalInterface
public interface DemoInterface {

    String USER_NAME = "admin";
    String USER_PASS = "1234";
    boolean login(String name, String pass);

}

public static void main(String[] args) {

        DemoInterface demoInterface = new DemoInterface() {
            @Override
            public boolean login(String name, String pass) {

                if (!USER_NAME.equals(name) || !USER_PASS.equals(pass)) {
                    return false;
                }
                return true;
            }
        };


        DemoInterface demoInterface1 = (name, pass) -> {
            if (!DemoInterface.USER_NAME.equals(name) || !DemoInterface.USER_PASS.equals(pass)) {
                return false;
            }
            return true;
        };

        System.out.println(demoInterface1.login("admin", "1234"));
    }

原文地址：http://www.cnblogs.com/wang1999an/p/16784119.html