第一章.封装

1.封装的介绍以及使用

 1.面向对象三大特征: [封装]    继承     多态
 2.什么是封装思想:
   a.为什么需要封装?封装的作用和含义?
     我要用洗衣机,只需要按一下按钮就可以了.有必要了解洗衣机内部构造吗?
   b.隐藏对象内部的复杂性,只对外公开简单的接口.便于外界调用,从而提高了系统的可扩展性,可维护性,安全性.通俗的说,把该隐藏的隐藏起来,把该暴露的暴露出来.这就是封装的设计思想
   
   将细节隐藏起来,对外提供一个暴露的接口,供我们使用者使用,我们只需要调用这个接口,接口中的细节(代码)就执行起来了
       
 3.封装思想中最具代表性的关键字:private(权限修饰符)-> 私有权限
   a.是一个权限修饰符,代表私有的
   b.用法:
     修饰一个成员变量
         private 数据类型 变量名
     修饰一个方法
         将public 改成 private
   c.特点:
     被private修饰的成员别的类不能直接访问,只能自己类中访问
         
 4.将属性私有化了,相当于将细节隐藏了起来,外界不能直接使用,然后我们可以对外提供(暴露)公共的接口:get/set方法
   getxxx(): 获取属性值
   setxxx(): 为属性赋值

 public class Person {
     private String name;
     private int age;
 ​
     //给私有的name提供公共接口:get/set
     public void setName(String xingMing) {
 ​
         name = xingMing;
     }
 ​
     public String getName() {
 ​
         return name;
     }
 ​
     //给私有的age提供公共接口:get/set
     public void setAge(int nianLing) {
         if (nianLing <= 0) {
             System.out.println("年龄不符合");
         } else {
             age = nianLing;
         }
     }
 ​
     public int getAge() {
 ​
         return age;
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Person person = new Person();
        /* person.name = "柳岩";
         person.age = -36;
         System.out.println(person.name);
         System.out.println(person.age);*/
 ​
         person.setName("柳岩");
         person.setAge(-36);
 ​
         System.out.println(person.getName() + "..." + person.getAge());
     }
 }
 ​

属性被private私有化了,相当于将细节隐藏了,外界无法直接调用了

提供get/set相当于对外提供了公共的接口

setxxx():为属性赋值

getxxx():获取属性值

快速跳到调用的对应位置:按住ctrl不放,点击

注意:属性没有被私有化,也可以提供get/set方法,但是没啥必要,因为没有被私有化的属性,可以直接点出来

2.this的介绍

 1.如果局部变量和成员变量重名了,遵循"就近原则",先访问局部变量
 2.this:概述:代表当前对象
   哪个对象调用的this所在的方法,this就代表哪个对象
     
   可以区分重名的局部变量和成员变量

 public class Person {
     String name;
 ​
     /*
        哪个对象调用的this所在的方法,this就代表哪个对象
      */
     public void speak(String name){
         System.out.println(this+".......");
         System.out.println(name+"您好,我是"+this.name);
     }
 }

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println(person1+"...");
        person1.name = "张翠山";
        person1.speak("张无忌");
    }
}

public class Person {
    private String name;
    private int age;

    //给私有的name提供公共接口:get/set
    public void setName(String name) {

        this.name = name;
    }

    public String getName() {

        return name;
    }

    //给私有的age提供公共接口:get/set
    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {

        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
       /* person.name = "柳岩";
        person.age = -36;
        System.out.println(person.name);
        System.out.println(person.age);*/

        person.setName("柳岩");
        person.setAge(36);

        System.out.println(person.getName() + "..." + person.getAge());
    }
}

3.构造方法

1.作用:new对象
2.特点:
  a.方法名和类名一致
  b.没有返回值,连void都没有

3.1空参构造

1.格式:
  类名(){
    
  }
2.作用:
  new对象用-> 一new 相当于调用了构造方法,构造方法就自动执行
3.特点:
  每个类都有一个无参构造方法,但是不同写出来,jvm会自动提供一个

3.2有参构造

1.格式:
  类名(参数){
    方法体
  }
2.作用:
  a.new对象
  b.为属性赋值
3.特点:
  jvm不会自动提供有参构造,如果写上了有参构造,jvm将不再提供空参构造
  所以建议,空参和有参构造都手动写上

public class Person {
    String name;
    int age;

    //空参构造
    public Person(){
        System.out.println("我是无参构造");
    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();

        //利用有参构造创建对象,并为属性赋值
        Person person1 = new Person("柳岩", 36);
        //调用get方法获取属性值
        System.out.println(person1.getName()+"..."+person1.getAge());
    }
}

小结:
  1.知道private的作用吗?私有成员,外界不能直接点
  2.知道get/set方法的作用吗?
    set方法:为属性赋值
    get方法:获取属性值
  3.知道this的作用吗?
    表示当前对象->哪个对象调用this所在的方法,this就代表哪个对象
    区分重名的成员变量和局部变量->this.后面的就是成员的
  4.知道无参构造作用吗?
    new对象的-> 不写jvm给一个
  5.知道有参构造作用吗?
    new 对象,为属性赋值
    写了有参构造,空参构造使用不了了
    建议,无参,有参都写上

第二章.标准JavaBean

JavaBean是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求：

（1）类必须是具体的和公共的，public class 类名

（2）并且具有无参数的构造方法，有参构造

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

public class ClassName{
  //私有化的成员变量
    
  //构造方法
  	//无参构造方法【必须】
  	//有参构造方法【建议】
  	
  //getXxx()
  //setXxx()
  //其他成员方法
}

com.atguigu.dao -> 专门装和数据库打交道的类 -> 持久层的类
com.atguigu.service-> 业务层的类
com.atguigu.pojo-> 专门装实体类->标准javabean
com.atguigu.controller->专门装和前端打交道的
com.atguigu.utils->专门装工具类

标准javabean一般都是根据数据库中的表定义出来

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
    private int id;
    private String name;

    public Student() {
    }

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

    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;
    }
}

通用组合键:alt+insert

1.生成无参构造:

2.生成有参构造:

3.生成get/set:

测试类，代码如下：

public class Test01 {
    public static void main(String[] args) {
        //set方法为属性赋值
        Student student = new Student();
        student.setId(1);
        student.setName("涛哥");
        System.out.println(student.getId()+"..."+student.getName());

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

        Student student1 = new Student(2, "翠儿");
        System.out.println(student1.getId()+"..."+student1.getName());
    }
}

第三章.继承

1.什么是继承

1. 父类怎么形成的:
   定义多个类之后,发现重复的代码太多了,我们没有必要每个类都要写一遍共性的代码
   所以,我们定义一个类,将共性的代码抽取出来 放到这个类中,此类就是"父类",其他的类就可以直接继承这个"父类",就可以使用父类中抽取出来的共性的代码了

2.继承:更倾向于是一种代码的设计理念

3.注意:
   子类可以继承父类中的私有和非私有成员
   但是在子类中不能使用私有成员

4.学习继承不要从"拥有"层面去理解
   要从"是否能使用"层面去理解

2.继承如何使用

 1.关键字:extends
 2.格式:
   子类 extends 父类
 3.父类也叫超类,也叫根类,基类
   子类也叫派生类

 public class Employee {
     String name;
     int age;
     public void work(){
         System.out.println("工作");
     }
 ​
     private void method(){
         System.out.println("私有的method");
     }
 }

 public class Teacher extends Employee{
 }

 public class Test {
     public static void main(String[] args) {
         Teacher teacher = new Teacher();
         teacher.name = "涛哥";
         teacher.age = 12;
         System.out.println(teacher.name+"..."+teacher.age);
         teacher.work();
         //teacher.method();父类中私有成员子类对象无法使用
     }
 }
 ​

如果一个类明确写出了extends 父类,那么此父类就是该类的亲爹类

如果一个类没有明确写出extends 父类,那么此类的父类就是Object

Object类是所有类的父类

2.1.在继承中,如何给父类中的私有成员赋值

 public class Employee{
     private String name;
     private int age;
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     public void work(){
         System.out.println("工作");
     }
 }
 ​

public class Teacher extends Employee {
}

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        /*teacher.name = "涛哥";
        teacher.age = 12;
        System.out.println(teacher.name+"..."+teacher.age);*/
        teacher.setName("翠儿");
        teacher.setAge(48);
        System.out.println(teacher.getName()+"..."+teacher.getAge());
        teacher.work();
        //teacher.method();父类中私有成员子类对象无法使用
    }
}

3.继承中,成员变量和成员方法的访问特点

3.1 成员变量

3.1.1 子类和父类中的成员变量不重名:

public class Fu {
    int numFu = 100;
}

public class Zi extends Fu{
    int numZi = 10;
}

public class Test01 {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        System.out.println(fu.numFu);
        //System.out.println(fu.numZi);父类对象不能调用子类特有成员

        //创建子类对象
        Zi zi = new Zi();
        System.out.println(zi.numZi);
        System.out.println(zi.numFu);
    }
}

总结:
  如果是父类对象,只能调用父类的,不能调用子类特有的
  如果是子类对象,既能调用自己的,还能调用父类的非私有成员

2.1.2.子类和父类中的成员变量重名

public class Fu {
    int num = 100;
}

public class Zi extends Fu{
    //int num = 10;
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Fu();
        System.out.println(fu.num);//父类中的num 100

        Zi zi = new Zi();
        System.out.println(zi.num);//10
    }
}

子类有,先调用子类的,子类没有找父类

总结:看等号左边是谁,就先调用谁的成员变量, 子类没有找父类(重名)

2.2 成员方法

2.2.1.子类和父类中的成员方法不重名:

public class Fu {
    public void methodFu(){
        System.out.println("我是父类中的成员方法");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("我是子类中成员方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        fu.methodFu();
        //fu.methodZi();//不能调用子类特有成员

        //创建子类对象
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();
    }
}

2.2.2.子类和父类中的成员方法重名

public class Fu {
    public void methodFu(){
        System.out.println("我是父类中的成员方法");
    }

    public void method(){
        System.out.println("我是父类中的method方法");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("我是子类中成员方法");
    }

    public void method(){
        System.out.println("我是子类中的method方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        fu.methodFu();
        fu.method();//父类中的method方法
        //fu.methodZi();//不能调用子类特有成员

        System.out.println("========================");
        //创建子类对象
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();
        zi.method();//调用的子类中method方法
    }
}

总结:看new的是谁,先调用谁的成员方法, 子类没有找父类(方法重名)

第四章.继承

1.方法的重写_Override

1.重写的前提:继承关系
2.概述:子类中有一个和父类一毛一样的方法
3.检测此方法是否为重写方法:  @Override

public class Animal {
    public void eat(){
        System.out.println("吃饭");
    }
}

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗啃骨头");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

1.1.注意事项

1. 子类方法重写父类方法，必须要保证权限大于等于父类权限。(权限指的是权限修饰符)
   public->protected->默认权限->private
2. 子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。
3. 私有方法不能被重写,构造方法不能被重写,静态方法也不能被重写

1.2.使用场景

1.当一个类中的某个功能做升级改造时,我们就可以重写这个方法

public class JianSheng {
    public void Q(){
        System.out.println("阿尔法突袭,欻欻歘");
    }

    public void W(){
        System.out.println("冥想,回血,bbd");
    }

    public void E(){
        System.out.println("真实伤害");
    }

    public void R(){
        System.out.println("疯狗模式");
    }
}

public class NewJianSheng extends JianSheng{
    public void R(){
        System.out.println("疯狗模式,无cd,见人就干");
    }
}

public class Test {
    public static void main(String[] args) {
        NewJianSheng newJianSheng = new NewJianSheng();
        newJianSheng.Q();
        newJianSheng.W();
        newJianSheng.E();
        newJianSheng.R();//重写的方法
    }
}

2.继承中构造方法的特点

1.注意:初始化子类对象时,先初始化父类对象
2.为什么:
  在构造方法的第一行,jvm会自动提供一个super()
  super()代表的是父类无参构造

public class Fu {
    public Fu(){
        System.out.println("我是父类无参构造");
    }
}

public class Zi extends Fu{
    /*
      1.注意:初始化子类对象时,先初始化父类对象
      2.为什么:
        在构造方法的第一行,jvm会自动提供一个super()
        super()代表的是父类无参构造
     */
    public Zi(){
        System.out.println("我是子类无参构造");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}

3.super和this的具体使用

3.1 super的具体使用

1.super:代表的父类对象,可以调用父类成员
2.使用:
  调用父类构造方法:在子类构造中:
         super()-> 调用父类无参构造 
         super(实参)->调用父类有参构造
  调用父类成员变量:在子类中
         super.成员变量名
  调用父类成员方法:在子类中
         super.成员方法名()
         super.成员方法名(实参)
      
3.注意:super要是放到构造中使用,必须要在构造第一行,无论调用父类有参还是无参构造

 public class Fu {
     int num = 100;
     public Fu(){
         System.out.println("我是父类无参构造");
     }
 ​
     public Fu(int i){
         System.out.println("我是父类有参构造");
     }
 ​
     public void method(){
         System.out.println("我是父类method方法");
     }
 }

 public class Zi extends Fu {
     int num = 10;
     public Zi(){
         //调用父类的无参构造
         //super();
 ​
         //调用父类有参构造
         super(1);
         System.out.println("我是子类无参构造");
     }
 ​
     public Zi(int i){
         System.out.println("我是子类有参构造");
     }
 ​
 ​
     public void method(){
         System.out.println(num);
         System.out.println(super.num);
         super.method();
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Zi zi = new Zi();
         zi.method();
     }
 }
 ​

3.2 this的具体使用

 1.概述:this代表的是当前对象
 2.使用:调用当前对象中的成员
     
   调用当前对象中的构造方法:在本类的构造中
       this()-> 调用当前对象的空参构造
       this(实参)->调用当前对象的有参构造
     
   调用当前对象中的成员变量:在本类中写:
       this.成员变量
   调用当前对象中的成员方法:在本类中写:
       this.成员方法()
       this.成员方法(实参)
           
 3.注意事项:
   如果在构造中使用this,需要在第一行,所以this和super不能在构造中同时写出来

 public class Zi {
     int num = 100;
 ​
     public Zi() {
         //this(10);
         System.out.println("我是空参构造");
     }
 ​
     public Zi(int num) {
         //super();
         this();
         System.out.println("我是有参构造");
     }
 ​
     public void method01(){
         int num = 10;
         System.out.println(num);//就近原则,先使用局部的变量
         System.out.println(this.num);//调用的成员变量
         this.method02();
         //method02();
     }
 ​
     public void method02(){
         System.out.println("哈哈哈哈");
     }
 }
 ​

4.继承的特点

 1.继承只能单继承,不支持多继承(一个儿子只能有一个亲爹)
   public class A extends B,C{}  -> 错误
 2.继承支持多层继承
   public class A extends B{}
   public class B extends C{}
 3.一个父类可以拥有多个子类
   public class B extends A{}
   public class C extends A{}

第五章.代码块

2.1构造代码块

 1.格式:
 {
   代码块
 }
 2.执行特点:
   优先于构造方法执行的,每new一次,构造代码块就会执行一次

 public class Zi {
     public Zi(){
         System.out.println("我是空参构造");
     }
 ​
     {
         System.out.println("我是构造代码块");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         Zi zi = new Zi();
         Zi zi1 = new Zi();
     }
 }

2.2静态代码块

 1.格式:
   static{
     代码
   }
 2.执行特点:
   优先于构造方法和构造代码块执行,且只执行一次

 public class Zi {
     public Zi(){
         System.out.println("我是空参构造");
     }
 ​
     {
         System.out.println("我是构造代码块");
     }
 ​
     //静态代码块
     static{
         System.out.println("我是静态代码块");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Zi zi = new Zi();
         Zi zi1 = new Zi();
     }
 }

2.3.静态代码块使用场景

 1.什么时候使用静态代码块:
   当一段代码或者初始化的变量,需要最先执行,且只执行一次时,可以选择静态代码块

第六章.抽象

1.抽象的介绍

 1.当将 共性的方法抽取出来,但是每一个子类对这个方法的实现不一样时,此方法就可以定义成抽象方法了抽象方法所在的类一定是抽象类
 ​
 2.抽象也是一种设计理念
 ​
 3.当抽取出来之后,形成一个抽象类,继承此类的都需要重写此父类的抽象方法
   也就意味着,凡是属于此抽象类的子类,都应该拥有这些抽取出来的功能
 ​
   相当于抽取出来,形成一种标准
 ​
 4.我们抽取出来之后,要求继承的子类,都应该有这些功能,至于怎么实现,需要到子类中重写,做具体实现
 ​
 5.特点:
   a.抽象方法所在的类一定是抽象类
   b.抽象类中不一定非得有抽象方法
   c.子类继承抽象类之后,需要重写抽象方法
   d.抽象类不能new对象,只能通过new子类,调用重写方法去实现

 1.关键字:abstract
 2.定义格式:
   a.抽象类:  public abstract class 类名{}
   b.抽象方法: 修饰符 abstract 返回值类型 方法名(参数);
 3.使用:
   a.定义子类,继承抽象父类
   b.重写抽象父类中的抽象方法
   c.创建子类对象(抽象父类不能new对象)
   d.调用重写的方法

 public abstract class Animal {
     public abstract void eat();
 }
 ​

 public class Dog extends Animal{
     @Override
     public void eat() {
         System.out.println("狗吃💩");
     }
 }
 ​

 public class Cat extends Animal{
     @Override
     public void eat() {
         System.out.println("猫吃🐟");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Dog dog = new Dog();
         dog.eat();
 ​
         Cat cat = new Cat();
         cat.eat();
     }
 }

2.抽象的注意事项

 1.抽象类不能直接new对象,只能创建非抽象子类的对象
 2.抽象类中,可以有构造方法,是供子类创建对象时,初始化父类中属性使用的
 3.抽象类中可以有成员变量,构造,成员方法
 4.抽象类中不一定非得有抽象方法,但是有抽象方法的类一定是抽象类
 5.抽象类的子类,必须重写父类中的所有抽象方法,否则,编译无法通过.除非该子类也是抽象类

 public abstract class Employee {
     private String name;
     private int age;
 ​
     public Employee() {
     }
 ​
     public Employee(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     public abstract void work();
     //public abstract void eat();
 }
 ​

 public  class Teacher extends Employee{
     public Teacher(){
 ​
     }
 ​
     public Teacher(String name,int age){
         super(name, age);
     }
     @Override
     public void work() {
         System.out.println(getName()+"今年"+getAge()+"岁了,他在讲课");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Teacher teacher = new Teacher();
         teacher.setName("涛哥");
         teacher.setAge(10);
         teacher.work();
 ​
         System.out.println("=========================");
 ​
         Teacher teacher1 = new Teacher("柳岩", 36);
         teacher1.work();
     }
 }
 ​

第七章.综合案例

 某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部、维护部）。
 研发部(Developer)根据所需研发的内容不同，又分为 JavaEE工程师 、Android工程师 ；
 维护部(Maintainer)根据所需维护的内容不同，又分为 网络维护工程师 、硬件维护工程师 。
 ​
 公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。
 ​
 工作内容:
 ​
 - JavaEE工程师： 员工号为xxx的 xxx员工，正在研发淘宝网站
 - Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
 - 网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通 
 - 硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机
 ​
 请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。

方式1:利用set赋值

 public abstract class Employee {
     private int id;
     private String name;
 ​
     public Employee() {
     }
 ​
     public Employee(int id, String name) {
         this.id = id;
         this.name = name;
     }
 ​
     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 abstract void work();
 }
 ​

 public abstract class Developer extends Employee{
 }

 public class JavaEE extends Developer{
     @Override
     public void work() {
         System.out.println("员工号为:"+getId()+"的"+getName()+"员工在搞网站");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         JavaEE javaEE = new JavaEE();
         javaEE.setId(1);
         javaEE.setName("涛哥");
         javaEE.work();
     }
 }
 ​

方式2:利用构造赋值

 public abstract class Employee {
     private int id;
     private String name;
 ​
     public Employee() {
     }
 ​
     public Employee(int id, String name) {
         this.id = id;
         this.name = name;
     }
 ​
     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 abstract void work();
 }
 ​

 public abstract class Developer extends Employee{
 ​
     public Developer() {
     }
 ​
     public Developer(int id, String name) {
         super(id, name);
     }
 }

 public class JavaEE extends Developer{
     public JavaEE() {
     }
 ​
     public JavaEE(int id, String name) {
         super(id, name);
     }
 ​
     @Override
     public void work() {
         System.out.println("员工号为:"+getId()+"的"+getName()+"员工在搞网站");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         JavaEE javaEE = new JavaEE();
         javaEE.setId(1);
         javaEE.setName("涛哥");
         javaEE.work();
 ​
         System.out.println("========================");
 ​
         JavaEE javaEE1 = new JavaEE(2, "柳岩");
         javaEE1.work();
     }
 }

第八章.多态

 1.面向对象三大特征:封装      继承       [多态]
 2.多态怎么学:
   学多态的前提
   学多态的new法
   学多态的好处
 ​

1.多态的介绍

 1.前提:
   a.必须有子父类继承关系,或者接口实现关系
   b.多态没有重写的方法,多态没有意义
   c.父类引用指向子类对象
       
     好比:double b = 10
         b = 100L
         b = 2.5F
 2.注意:
    多态主要是操作重写的方法
    多态的前提下,不能调用子类特有方法的

2.多态的基本使用

 1.定义一个父类
 2.定义一个子类,继承父类
 3.重写父类方法
 4.创建对象:父类引用指向子类对象
 5.调用重写的方法

 public class Animal {
     public void eat(){
         System.out.println("动物都要吃饭");
     }
 }

 public class Dog extends Animal{
     public void eat(){
         System.out.println("狗啃骨头");
     }
 ​
     //特有方法
     public void lookDoor(){
         System.out.println("狗会看门");
     }
 }
 ​

 public class Cat extends Animal{
     public void eat(){
         System.out.println("猫吃鱼");
     }
 ​
     //特有方法
     public void catchMouse(){
         System.out.println("猫会抓老鼠");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         //原始方式
         Dog dog = new Dog();
         dog.eat();
         dog.lookDoor();
 ​
         Cat cat = new Cat();
         cat.eat();
         cat.catchMouse();
 ​
         System.out.println("==================");
 ​
         //多态形式
         Animal animal = new Dog();
         animal.eat();
         //animal.lookDoor();多态情况下,不能直接调用子类特有方法
     }
 }
 ​

3.多态的条件下成员的访问特点

3.1成员变量

 public class Fu {
     int num = 100;
 }

 public class Zi extends Fu{
     int num = 10;
 }

 public class Test01 {
     public static void main(String[] args) {
         Fu fu = new Zi();
         System.out.println(fu.num);//调用的是父类的
     }
 }
 ​

 看等号左边是谁,先调动谁的成员变量

3.2成员方法

 public class Fu {
     int num = 100;
     public void method(){
         System.out.println("我是父类中的method方法");
     }
 }

 public class Zi extends Fu{
     int num = 10;
 ​
     public void method(){
         System.out.println("我是子类中的method方法");
     }
 ​
     //特有方法
     public void methodZi(){
         System.out.println("我是子类特有方法");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Fu fu = new Zi();
         System.out.println(fu.num);
         fu.method();
         //fu.methodZi();多态情况下,不能直接调用子类特有方法
     }
 }
 ​

 看new的是谁,先调用谁中的成员方法

4.多态的好处(为什么学多态)

 1.原始new对象方式:
   好处:既能调用父类的,还能调用自己特有的,还能调用重写的
   坏处:扩展性差
 2.多态方式
   好处:扩展性强
   坏处:不能直接调用子类特有方法

 public class Animal {
     public void eat(){
         System.out.println("动物都要吃饭");
     }
 }

 public class Dog extends Animal {
     public void eat(){
         System.out.println("狗啃骨头");
     }
 ​
     //特有方法
     public void lookDoor(){
         System.out.println("狗会看门");
     }
 }
 ​

 public class Cat extends Animal {
     public void eat(){
         System.out.println("猫吃鱼");
     }
 ​
     //特有方法
     public void catchMouse(){
         System.out.println("猫会抓老鼠");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
        /* Dog dog = new Dog();
         method(dog);
 ​
         Cat cat = new Cat();
         method(cat);*/
 ​
        Dog dog = new Dog();
        method(dog);
 ​
         Cat cat = new Cat();
         method(cat);
 ​
     }
 ​
    /* public static void method(Dog dog){
         dog.eat();
     }
 ​
     public static void method(Cat cat){
         cat.eat();
     }*/
 ​
     public static void method(Animal animal){//Animal animal = dog->多态  Animal animal = cat
         animal.eat();
     }
 }

 参数位置传递父类类型,可以接收任意他的子类对象,接收到哪个子类对象,就调用哪个子类对象重写的方法

5.多态中的转型

5.1向上转型

 父类引用指向子类对象->默认
 弊端:不能直接调用子类特有功能

5.2向下转型

 1.向下转型相当于强转
   父类 对象名 = new 子类()-> 向上转型   ->  double b = 10
   子类 对象名 = (子类)父类对象名   -> int i = (int)b;
     
 2.特点:
   能调用子类特有功能了

 public class Animal {
     public void eat(){
         System.out.println("动物都要吃饭");
     }
 }
 ​

 public class Cat extends Animal {
     public void eat(){
         System.out.println("猫吃鱼");
     }
 ​
     //特有方法
     public void catchMouse(){
         System.out.println("猫会抓老鼠");
     }
 }

 public class Dog extends Animal {
     public void eat(){
 ​
         System.out.println("狗啃骨头");
     }
 ​
     //特有方法
     public void lookDoor(){
 ​
         System.out.println("狗会看门");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         Animal animal = new Dog();
         animal.eat();
         //向下转型
         Dog dog = (Dog) animal;
         dog.lookDoor();
     }
 }

6.转型可能会出现的问题

 1.向下转型容易出现的问题:
   ClassCastException-> 类型转换异常-> 转型时等号左右两边类型不一致
 2.判断类型关键字: instanceof  -> boolean
 3.使用语法:
   对象名 instanceof 类型 -> 关键字前面的对象是否属于关键字后面的类型

 public class Animal {
     public void eat(){
         System.out.println("动物都要吃饭");
     }
 }

 public class Dog extends Animal {
     public void eat(){
 ​
         System.out.println("狗啃骨头");
     }
 ​
     //特有方法
     public void lookDoor(){
 ​
         System.out.println("狗会看门");
     }
 }
 ​

 public class Cat extends Animal {
     public void eat(){
         System.out.println("猫吃鱼");
     }
 ​
     //特有方法
     public void catchMouse(){
         System.out.println("猫会抓老鼠");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         Dog dog = new Dog();
         method(dog);
 ​
         Cat cat = new Cat();
         method(cat);
     }
 ​
     private static void method(Animal animal) {
        if (animal instanceof Dog){
            animal.eat();
            Dog dog = (Dog)animal;
            dog.lookDoor();
        }
 ​
        if (animal instanceof Cat){
            animal.eat();
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
     }
 }
 ​

第九章.接口

1.接口的介绍

 1.接口:标准,规则
 2.特点:单一, 成员单一
 ​
 3.成员:
   jdk8之前:
      a.被public static final修饰的成员变量,不写static final 默认也有
      b.抽象方法-> 不写abstract,默认也有
 ​
  jdk8:新加了成员
     a.静态方法:带static
     b.默认方法:带default的方法
 ​
 jdk9:新加了成员
     私有方法:private
 ​
 ​
 4.关键字:
    interface  -> 接口
    implements -> 实现

2.接口的定义以及使用

 1.接口的定义:
   public interface 接口名{}
 2.基本使用:
   a.定义一个类作为实现类,去实现接口-> implements
   b.重写接口中的抽象方法
   c.创建实现类对象(接口不能直接new对象),调用重写的方法

 public interface USB {
     public abstract void open();
     public abstract void close();
 }
 ​

 public class Mouse implements USB{
     @Override
     public void open() {
         System.out.println("鼠标开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("鼠标关闭");
     }
 ​
     //特有方法
     public void click(){
         System.out.println("鼠标可以点击");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         //原始方式
         Mouse mouse = new Mouse();
         mouse.open();
         mouse.close();
         mouse.click();
 ​
         System.out.println("======================");
 ​
         //多态形式
         USB usb = new Mouse();
         usb.open();
         usb.close();
         //调用实现类特有方法,需要向下转型
         Mouse mouse1 = (Mouse)usb;
         mouse1.click();
 ​
     }
 }

3.接口中的成员

3.1抽象方法

 1.定义:
   修饰符 abstract 返回值类型 方法名(参数);
 2.注意:
   在接口中抽象方法即使不写abstract默认也有
 3.使用:
   a.定义一个类作为实现类,去实现接口-> implements
   b.重写接口中的抽象方法
   c.创建实现类对象(接口不能直接new对象),调用重写的方法

 public interface USB {
     public void open();
     public void close();
 }

 public class Mouse implements USB {
 ​
     //特有方法
     public void click(){
 ​
         System.out.println("鼠标可以点击");
     }
 ​
     @Override
     public void open() {
         System.out.println("鼠标开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("鼠标关闭");
     }
 }

 public class KeyBoard implements USB{
     @Override
     public void open() {
         System.out.println("键盘开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("键盘关闭");
     }
 ​
     //特有方法
     public void qiaoJi(){
         System.out.println("敲击键盘");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Mouse mouse = new Mouse();
         method(mouse);
 ​
         KeyBoard keyBoard = new KeyBoard();
         method(keyBoard);
     }
 ​
     public static void method(USB usb){//USB usb = mouse  USB usb = keyboard
 ​
         if (usb instanceof Mouse){
             usb.open();
             usb.close();
 ​
             Mouse mouse = (Mouse)usb;
             mouse.click();
         }
 ​
         if (usb instanceof KeyBoard){
             usb.open();
             usb.close();
 ​
             KeyBoard keyBoard = (KeyBoard)usb;
             keyBoard.qiaoJi();
         }
 ​
     }
 }

3.2默认方法

 1.定义:
   修饰符 default 返回值类型 方法名(参数){
      方法体
      return 结果
   }
 2.使用:
   a.定义实现类,实现接口
   b.重写默认方法(默认方法可重写,可不重写)
   c.创建实现类对象,调用默认方法

 public interface USB {
     public default void open(){
         System.out.println("鼠标开启...默认方法");
     }
 }

 public class Mouse implements USB{
     @Override
     public void open(){
         System.out.println("鼠标开启...重写的默认方法");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         Mouse mouse = new Mouse();
         mouse.open();
     }
 }

3.3静态方法

 1.定义:
   修饰符 static 返回值类型 方法名(参数){
      方法体
      return 结果
   }
 2.使用:
   接口名直接调用

 public interface InterfaceA {
     public static String method(){
         return "柳岩和涛哥...的故事";
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         String result = InterfaceA.method();
         System.out.println("result = " + result);
     }
 }

3.4成员变量

 1.格式:
   public static final 数据类型 变量名 = 值
 2.注意:
   a.即使不写 static final 默认也有
   b.final关键字代表最终的,被final修饰的变量不能被二次赋值,所以我们一般跟这种变量叫做常量 
   c.习惯上来说,被static final修饰的变量名都是大写

 public interface InterfaceA {
    public static final int NUM1 = 100;
    int NUM2 = 1000;
 ​
 }

 public class Test01 {
     public static void main(String[] args) {
         System.out.println(InterfaceA.NUM1);
         System.out.println(InterfaceA.NUM2);
     }
 }

4.接口的特点

 类继承的特点:
 1.继承只支持单继承,不能多继承
 2.继承支持多层继承
 3.一个父类可以拥有多个子类

 接口的特点:
 1.接口可以多继承
   public interface InterfaceA extends InterfaceB,InterfaceC{}
 2.接口可以多实现
   public class InterfaceImpl implements InterfaceA,InterfaceB{}
 3.一个类可以继承一个父类的同时,实现一个或多个接口
   public class Zi extends Fu implements InterfaceB,InterfaceC{}
 ​
 ​
 一个类实现了一个或者多个接口,那么需要将所有接口中的抽象方法全部重写掉

当一个类实现多个接口时,如果接口中的抽象方法有重名且参数一样的,只需要重写一次

 public interface InterfaceA {
 void methodA();
 ​
 void method();
 }

 public interface InterfaceB {
 void methodB();
 ​
 void method();
 }
 ​

 public class InterfaceImpl implements InterfaceA, InterfaceB {
 @Override
 public void methodA() {
   System.out.println("我是重写的接口A中的methodA方法");
 }
 ​
 @Override
 public void methodB() {
   System.out.println("我是重写的接口B中的methodB方法");
 }
 ​
 ​
 ​
 @Override
 public void method() {
   System.out.println("我是重写的method方法");
 }
 ​
 }

当一个类实现多个接口时,如果默认方法有重名的,而且参数也一样的,要重写一次

 public interface InterfaceA {
 void methodA();
 ​
 void method();
 ​
 public default void methodDef(int i){
   System.out.println("我是接口A中的methodDef方法");
 }
 }
 ​

 public interface InterfaceB {
 void methodB();
 ​
 void method();
 ​
 public default void methodDef(){
   System.out.println("我是接口B中的methodDef方法");
 }
 }
 ​

 public class InterfaceImpl implements InterfaceA, InterfaceB {
 @Override
 public void methodA() {
   System.out.println("我是重写的接口A中的methodA方法");
 }
 ​
 @Override
 public void methodB() {
   System.out.println("我是重写的接口B中的methodB方法");
 }
 ​
 ​
 ​
 @Override
 public void method() {
   System.out.println("我是重写的method方法");
 }
 ​
 }

5.接口和抽象类的区别

 相同点:
   1.都位于继承体现的顶端
   2.都不能new
   3.都有抽象方法,继承或者实现之后都需要重写这些抽象方法
 不同点:
   1.抽象类成员比较丰富,可以有属性,构造,普通方法,抽象方法等
   2.接口成员比较单一,一般抽取的都是抽象方法,是功能的大集合
   3.类不能多继承,但是接口可以

小结:

1.抽象方法:带abstract的,可以不写,默认也有-> 必须要重写

2.默认方法:带default-> 可重写可不重写

3.静态方法:带static -> 接口名直接调用

4.成员变量:带static final 不写也有 -> 接口名直接调用

6.综合练习

 定义笔记本类，具备开机，关机和使用USB设备的功能。具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用;
 进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
 ​
 - USB接口，包含开启功能、关闭功能
 - 笔记本类，包含开机功能、关机功能、使用USB设备功能
 - 鼠标类，要符合USB  实现USB接口
 - 键盘类，要符合USB接口  实现USB接口

 public interface USB {
     void open();
     void close();
 }
 ​

 public class Mouse implements USB{
     @Override
     public void open() {
         System.out.println("鼠标开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("鼠标关闭");
     }
 ​
     //特有方法
     public void click(){
         System.out.println("我要点击");
     }
 }
 ​

 public class KeyBoard implements USB{
     @Override
     public void open() {
         System.out.println("键盘开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("键盘关闭");
     }
 ​
     //特有方法
     public void qiaoJi(){
         System.out.println("我要敲键盘");
     }
 }
 ​

 public class NoteBook {
     //开机
     public void start(){
         System.out.println("我开机了");
     }
 ​
     public void useUSB(USB usb){//USB usb = mouse;USB usb = keyBoard
         usb.open();
         usb.close();
     }
 ​
     //关机
     public void stop(){
         System.out.println("我关机了");
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         //创建笔记本对象
         NoteBook noteBook = new NoteBook();
         //创建Mouse对象
         Mouse mouse = new Mouse();
 ​
         //创建键盘对象
         KeyBoard keyBoard = new KeyBoard();
 ​
         noteBook.start();
         noteBook.useUSB(mouse);
 ​
         noteBook.useUSB(keyBoard);
         noteBook.stop();
 ​
     }
 }
 ​

7.综合练习升级版

 public interface USB {
     void open();
     void close();
 }

 public class Mouse implements USB{
     @Override
     public void open() {
         System.out.println("鼠标开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("鼠标关闭");
     }
 ​
     //特有方法
     public void click(){
         System.out.println("我要点击");
     }
 }
 ​

 public class KeyBoard implements USB{
     @Override
     public void open() {
         System.out.println("键盘开启");
     }
 ​
     @Override
     public void close() {
         System.out.println("键盘关闭");
     }
 ​
     //特有方法
     public void qiaoJi(){
         System.out.println("我要敲键盘");
     }
 }
 ​

 public class NoteBook {
     //开机
     public void start(){
         System.out.println("我开机了");
     }
 ​
     public void useUSB(USB usb){//USB usb = mouse;USB usb = keyBoard
        if (usb instanceof Mouse){
            usb.open();
            Mouse mouse = (Mouse)usb;
            mouse.click();
            usb.close();
        }
         System.out.println("======================");
        if (usb instanceof KeyBoard){
            usb.open();
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.qiaoJi();
            usb.close();
        }
 ​
     }
 ​
     //关机
     public void stop(){
         System.out.println("我关机了");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         //创建笔记本对象
         NoteBook noteBook = new NoteBook();
         //创建Mouse对象
         Mouse mouse = new Mouse();
 ​
         //创建键盘对象
         KeyBoard keyBoard = new KeyBoard();
 ​
         noteBook.start();
         noteBook.useUSB(mouse);
 ​
         noteBook.useUSB(keyBoard);
         noteBook.stop();
 ​
     }
 }

第十章.权限修饰符

1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

• public：公共的,最高权限,被public修饰的成员,在哪里都能访问
• protected：受保护的
• default：:默认的 注意 不写权限修饰符就是默认权限,不能直接把default写出来
• private：私有的,只能在自己的类中直接访问

2 不同权限的访问能力

	public	protected	default（空的）	private
同一类中	yes	yes	yes	yes
同一包中不同类	yes	yes	yes	no
不同包的子类	yes	yes	no	no
不同包中的无关类	yes	no	no	no

public具有最大权限,private有最小权限

编写代码时,如果没有特殊的考虑,建议这样使用权限:

 1.javabean中的成员变量(属性),用private-> 封装思想
 2.构造方法建议用public->为了方便new对象
 3.成员方法建议用public->为了方便调用

第十一章.final关键字

 1.学final如何使用
 2.被final修饰之后的特点
     
 3.final:最终的
     
   final修饰一个类
   final修饰一个方法
   final修饰一个局部变量
   final修饰一个对象
   final修饰一个成员变量

1.final修饰类

 1.格式:
   public final class 类名{}
 2.特点:
   被final修饰的类不能被继承->太监类

 public final class Animal {
 }

 public class Dog /*extends Animal*/{//被final修饰的类不能被继承
 }

2.final修饰方法

 1.格式:
   修饰符 final 返回值类型 方法名(参数){
      方法体
      return 结果;
   }
 2.特点:
   a.被final修饰的方法不能被重写
   b.abstract和final不能同时使用

 public abstract class Animal {
     public final void eat(){
         System.out.println("动物要吃饭");
     }
 ​
     /*
       abstract修饰的方法必须被重写
       final修饰的方法不能被重写
       所以abstract和final不能同时使用
      */
     //public final abstract void drink();
 }
 ​

 public class Dog extends Animal{
    /* @Override
     public void drink() {
         System.out.println("狗喝水");
     }*/
    /* @Override
     public void eat(){
         System.out.println("狗吃骨头");
     }*/
 }
 ​

3.final修饰局部变量

 1.格式:
   final 数据类型 变量名 = 值
 2.特点:
   被final修饰的局部变量不能被二次赋值,可视为常量

 public class Test01 {
     public static void main(String[] args) {
         final int num = 10;
         //num = 10; 被final修饰的变量不能被二次赋值
         System.out.println(num);
         
         
         final int num2;
         num2 = 100;
         //num2 = 100;被final修饰的变量不能被二次赋值
         System.out.println(num2);
     }
 }

4.final修饰对象

 1.格式:
   new对象时前面加个final即可
 2.特点: 
   被final修饰的对象,地址值不能改变,但是对象中的属性值可以改变

 public class Person {
     private String name;
     private int age;
 ​
     public Person() {
     }
 ​
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         final Person p1 = new Person("柳岩", 36);
         System.out.println(p1.getName()+"..."+p1.getAge());
 ​
         //p1 = new Person("涛哥",18);
 ​
         p1.setName("林志玲");
         p1.setAge(10);
         System.out.println(p1.getName()+"..."+p1.getAge());
     }
 }

5.final修饰成员变量

 1.格式:
   final 数据类型 变量名 = 值
 2.特点:
   a.需要手动赋值
   b.不能被二次赋值

 public class Person {
     final String name = "李云龙";
 ​
     public Person() {
        
     }
 ​
    /* public Person(String name) {
         this.name = name;
     }*/
 ​
     public String getName() {
         return name;
     }
 ​
    /* public void setName(String name) {
         this.name = name;
     }*/
 }
 ​

第十二章.内部类

 1.什么时候使用内部类:
   当一个事物的内部,还有一个部分需要完整的结构进行描述,而这个内部的完成的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类
   比如:人类都有心脏,人类本身需要用属性,行为去描述,那么人类内部的心脏也需要心脏特殊的属性和行为来描述,此时心脏就可以定义成内部类,人类中的一个内部类
   
   当一个类内部的成员也需要用属性和行为描述时,就可以定义成内部类了
   
 2.在java中允许一个类的定义位于另一个类的内部,前者就称为内部类,后者称之为外部类
   public class A{
     class B{
     }
   }
 ​
   B类就是A类的内部类
   A类就是B类的外部类
    
 3.分类:
   成员内部类:(静态,非静态)
   局部内部类
   匿名内部类(重点)

1 静态成员内部类

 1.格式:直接在定义内部类的时候加上static关键字即可
   public class A{
     static class B{
     }
   }
 2.注意:
   a.内部类中可以定义属性,方法,构造等
   b.静态内部类可以被final或者abstract修饰
     被final修饰,不能被继承
     被abstract修饰,不能new
   c.静态内部类不能调用外部的非静态成员(静态不能直接调用非静态)
   d.内部类还可以被四种权限修饰符所修饰
  
 3.调用静态内部类成员:
   外部类.内部类 对象名 = new 外部类.内部类()

 public class Person {
     public void eat(){
         System.out.println("人要吃饭");
         //jump();
         //new Heart().jump();
     }
 ​
     //静态成员内部类
     static class Heart{
         public void jump(){
             System.out.println("心脏跳起来");
 ​
             //eat();//在静态内部类中不能直接调用外部类的非静态成员
 ​
             new Person().eat();
         }
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         //外部类.内部类 对象名 = new 外部类.内部类()
         Person.Heart heart = new Person.Heart();
         heart.jump();
     }
 }
 ​

2 非静态成员内部类

 1.格式:
   类名{
       class 类名{
           
       }
   }
 2.注意:
   a.内部类中可以定义属性,方法,构造等
   b.非静态内部类可以被final或者abstract修饰
     被final修饰,不能被继承
     被abstract修饰,不能new
   c.还可以被四种权限修饰符所修饰
   
 3.调用非静态内部类成员
    外部类.内部类 对象名 = new 外部类().new 内部类()

 public class Person {
     public void eat(){
         System.out.println("人要吃饭");
         //jump();//外边的不能直接调用小作用域的成员
         //new Heart().jump();
     }
 ​
     //非静态成员内部类
      class Heart{
         public void jump(){
             System.out.println("心脏跳起来");
 ​
             //eat();//非静态能直接调用非静态的
 ​
             new Person().eat();
         }
     }
 }

 public class Test01 {
     public static void main(String[] args) {
        //外部类.内部类 对象名 = new 外部类().new 内部类()
         Person.Heart heart = new Person().new Heart();
         heart.jump();
     }
 }

如果外部类的成员变量和内部类的成员变量以及局部变量重名,怎么区分?

 public class Person {
 //外部类的成员变量
 String name = "柳岩";
 class Heart{
 //内部类的成员变量
 String name = "心脏";
 public void display(String name){
    System.out.println(name);//局部变量name->就近原则
    System.out.println(this.name);//内部类成员变量 name
    System.out.println(Person.this.name);//外部类成员变量 name
 }
 }
 }

 public class Test01 {
 public static void main(String[] args) {
 Person.Heart heart = new Person().new Heart();
 heart.display("金莲");
 }
 }

3 局部内部类

 1.可以定在方法中,代码块中,构造方法中

 public class Person {
 ​
     public void method(){
         class Heart{
             public void jump(){
                 System.out.println("心跳");
             }
         }
 ​
         new Heart().jump();
     }
 }

 public class Test01 {
     public static void main(String[] args) {
         new Person().method();
     }
 }

 public interface USB {
     void open();
 }

 public class Test01 {
     public static void main(String[] args) {
         USB usb = method();
         usb.open();
     }
 ​
     public static USB method(){
         class Mouse implements USB{
             @Override
             public void open() {
                 System.out.println("鼠标开启");
             }
         }
 ​
         return new Mouse();
     }
 }
 ​

4.匿名内部类(重点)

匿名内部类其实可以理解为是没有名字的实现类或者子类

 1.是内部类的简化写法,他的本质是一个"带具体实现的","父类或者父接口的","匿名的","子类对象".开发中,最常用到的内部类就是匿名内部类,以接口为例,当我们使用一个接口时,写如下几步:
   a.创建实现类
   b.实现接口
   c.重写抽象方法
   d.创建实现类或者子类对象,调用重写的方法
 2.匿名内部类:没有名字的实现类或者子类
 3.作用:
   可以用一种格式,将上面的四步,四合一
       
 4.匿名内部类格式:
   new 接口/抽象类(){
     重写方法
   }.重写的方法();
 ​
   或者
   接口名/抽象类名 对象名 = new 接口/抽象类(){
     重写方法
   }
   对象名.重写的方法();
 ​
 5.注意:匿名内部类看上去new的是接口或者抽象类,实际上代表的是实现类对象或者子类对象

 public interface USB {
     void open();
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
        new USB(){
            @Override
            public void open() {
                System.out.println("鼠标开启");
            }
        }.open();
 ​
         System.out.println("========================");
 ​
         USB usb = new USB() {
             @Override
             public void open() {
                 System.out.println("键盘开启");
             }
         } ;
 ​
         usb.open();
     }
 }

4.2 匿名内部类复杂用法_当参数传递

 public interface USB {
     void open();
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         method(new USB() {
             @Override
             public void open() {
                 System.out.println("鼠标开启");
             }
         });
     }
 ​
     public static void method(USB usb){
         usb.open();
     }
 }

4.3 匿名内部类复杂用法_当返回值返回

 public interface USB {
     void open();
 }

 public class Test02 {
     public static void main(String[] args) {
         USB usb = method();
         usb.open();
     }
 ​
     public static USB method(){
        return new USB() {
            @Override
            public void open() {
                System.out.println("鼠标开启");
            }
        };
     }
 }

第十三章.Object类

1.Object的介绍

 1.概述:所有的类的顶级父类,所有的类都会直接或者间接的继承Object类
 2.特点:
   a.如果一个类没有明确的写出extends 父类,那么此类的亲爹就是Object
   b.如果一个类明确的写出了extends 父类,那么Object将成为此类的间接父类
   c.Object是lang包下的类

快捷键:

1.按住ctrl,鼠标点击对应的类,方法等,会快速跳转到被调用的位置

2.按:alt+7,快速看当前类中的成员

3. 按:ctrl+n,快速搜索要使用的类

2.Object类中的toString方法

 1.Object类中的toString
   public String toString() {
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
   }
 2.作用:返回的是对象的字符串表示形式
     
 3.注意:
   a.如果直接输出对象名,默认调用Object中的toString方法,而返回的就是"地址值"
       
 4.结论:
   如果一个类没有重写Object类中的toString方法,那么输出对象名,默认调用Object类中的toString方法,输出地址值
   如果一个类重写了Object类中的toString方法,那么输出对象名,会调用重写的toString方法,那么如果再输出地址值,重写toString就没有意义了,所以重写toString之后应该输出的是对象的内容

 public class Person {
     private String name;
     private int age;
 ​
     public Person() {
     }
 ​
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     @Override
     public String toString() {
         return "Person{" +
                 "name='" + name + ''' +
                 ", age=" + age +
                 '}';
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Person person1 = new Person("柳岩",36);
         System.out.println(person1);//com.atguigu.a_object.Person@1540e19d
         System.out.println(person1.toString());//com.atguigu.a_object.Person@1540e19d
 ​
         ArrayList<String> list = new ArrayList<>();
         list.add("柳岩");
         System.out.println(list);
     }
 }
 ​

总结:

如果输出对象名不想输出地址值的话,就在此对象中重写toString方法,输出内容

快捷键:alt+insert->toString

3.Object类中的equals方法

 1.equals方法:比较两个对象是否相等
   public boolean equals(Object obj) {
     return (this == obj);
   }
 ​
   ==:针对于基本类型,比较的是值
      针对于引用类型,比较的是地址值

 结论:
   1.如果对象中没有重写Object类中的equals方法,那么使用的equals,就是调用的Object中的,而Object类中的equals只比较地址值
   2.如果对象中重写了Object类中的equals方法,再比较地址值就没意义,所以我们重写equals方法之后,应该比较对象之间的内容

 public class Person {
     private String name;
     private int age;
 ​
     public Person() {
     }
 ​
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     @Override
     public String toString() {
         return "Person{" +
                 "name='" + name + ''' +
                 ", age=" + age +
                 '}';
     }
 ​
     /*
       问题1:obj.name或者obj.age为什么报错?
            obj = p2-> 多态
            name和age是Person特有的,所以多态情况下,不能调用子类特有的
       解决问题1:
            向下转型
 ​
       问题2:如果obj接收的不是Person类型,那么向下转型会出现
            类型转换异常
       解决问题2:
            先判断类型
 ​
       问题3:如果传递null呢?
            直接做非空判断
 ​
       问题4:如果比较自己呢?
            直接返回 true
      */
    /* public boolean equals(Object obj){
         //比较自己
         if (this==obj){
             return true;
         }
 ​
         //非空判断
         if (obj==null){
             return false;
         }
 ​
         //判断类型
         if (obj instanceof Person){
             //向下转型
             Person p2 = (Person)obj;
             return this.name.equals(p2.name) && this.age==p2.age;
         }
 ​
         return false;
 ​
     }*/
 ​
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Person person = (Person) o;
         return age == person.age &&
                 Objects.equals(name, person.name);
     }
     
 }
 ​
 ​
 ​
 ======================================================================
     
 public class Test02 {
     public static void main(String[] args) {
         Person p1 = new Person("柳岩", 36);
         Person p2 = new Person("柳岩", 36);
 ​
 ​
         ArrayList<String> list = new ArrayList<>();
 ​
         //System.out.println(p1.equals(p2));
         System.out.println(p1.equals(p1));//false
 ​
 ​
         System.out.println("===================");
         String s1 = new String("abc");
         String s2 = new String("abc");
         System.out.println(s1.equals(s2));//true
     }
 }
 ​

 总结:如果想比较两个对象的内容,直接在对象中重写equals方法->  alt+insert-> equals and hashcode->啥也不要管,一路next

 public class Test03 {
 public static void main(String[] args) {
   String s = null;
 ​
   /*
      判断s的内容是否为abc
 ​
      s接收的值不确定,所以不应该让不确定的变量在前面去点方法
 ​
      应该将确定的字符串放到前面去点方法
 ​
    */
  /* if (s.equals("abc")){
       System.out.println("s的内容是abc");
   }*/
 ​
  /* if ("abc".equals(s)){
       System.out.println("s的内容是abc");
   }*/
 ​
 ​
  /*
    工具类:Objects
 ​
    方法:equals
 ​
    作用:防空指针
   */
 ​
  if (Objects.equals(s,"abc")){
      System.out.println("s的内容是abc");
  }
 }
 }

总结:

如果想直接输出对象名不是地址值,重写toString

如果两个对象比较不是比较地址值,重写equals

怎么重写:alt+insert

4.Object类中的getClass()方法

 1.方法:Class<?> getClass()  返回class 对象

 Class<?> getClass()    -> 获取的是指定类的Class对象

 public class Test04 {
     public static void main(String[] args) {
         Person p = new Person("柳岩", 36);
         System.out.println(p.getClass());
     }
 }

 运行结果:class com.atguigu.a_object.Person

 1.世间万物 有对象
   人类 Person
   动物 Animal
     
 2.成员变量  Field
   成员方法  Method
   class文件  Class

5.native方法

     private static native void registerNatives();->将当前类中的native方法注册进来
     static {
         registerNatives();//注册本地方法
     }
     方法作用:当该类被加载的时候，调用该方法完成对该类中本地方法的注册
         
             在Object类中，除了有registerNatives这个本地方法之外，还有hashCode()、clone()等本地方法，而在Class类中有forName0()这样的本地方法等等。也就是说，凡是包含registerNatives()本地方法的类，同时也包含了其他本地方法。所以，显然，当包含registerNatives()方法的类被加载的时候，注册的方法就是该类所包含的除了registerNatives()方法以外的所有本地方法
             
      registerNatives()注册当前类的本地方法
 ​
 1.native:关键字->代表的本地方法
 2.本地方法是有方法体的:c语言编写,本地方法的方法体源码没有对我们开源,所以我们看不到方法体,简单理解为本地方法就是对java语言的扩展,比如:后面io流部分,很多功能java本身没有,比如读写,那么就需要调用本地方法进进行读写
 ​
 3.位置:在本地方法栈运行
 4.意义:跟系统打交道

 1.registerNatives()用于注册本地方法的,可以将本地方法注册到java中来,在java的世界中就可以直接使用本地方法了
 2.本地方法主要是为了对java语言不具备的功能进行扩充
 3.运行在本地方法栈中

6.GC垃圾回收简介

运行垃圾回收器，JVM将从堆内存中清理对象，清理对象的同时会调用对象的finalize()方法，JVM的垃圾回收器是通过另一个线程开启的，因此程序中的效果并不明显。

 1.方法:System类中的方法:public static void gc()->运行垃圾回收器
 2.GC:什么时候回收对象(如果我们的对象没有用了)
   比如:  Person p = new Person()
         p = null
        
         GC ROOTS->根据可达性算法判断这个对象的引用是否能到GC ROOTS,如果从 GC ROOTS出发,找不到对应的应用,gc会判断这个对象该死
         
 3.
   构造方法:创建对象
   析构函数:销毁对象, C语言中才有这个析构函数的概念
   
   finalize():在回收之前,会自动调用这个方法,不是垃圾回收器调用的,是本类对象调用的, 是垃圾回收器通知当前类去调用此方法进行对象销毁 

 public class Person {
     @Override
     protected void finalize() throws Throwable {
         System.out.println(this+"....."+"被回收了");
     }
 }
 ​

 public class Test01 {
     public static void main(String[] args) {
         Person person = new Person();
         //System.out.println(person);
 ​
         person = null;
 ​
         //获取gc垃圾回收器
         System.gc();
     }
 }

 垃圾回收关键点:
 1.垃圾回收机制只回收JVM堆内存里的对象空间。
 2.对其他物理连接，比如数据库连接(Connection)、输入流输出流(IO)、Socket连接(网络编程)无能为力
 3.现在的JVM有多种垃圾回收实现算法，表现各异。
 4.垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行
 5.可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。
 6.程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有
   一些效果，但是系统是否进行垃圾回收依然不确定。
 7.垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。
 8.永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制通知。

第十四章.异常

1.异常介绍

 1.概述:代码不正常,在java中其实是一个一个的类
 2.之前见过的异常:
   NullPointerException
   ArrayIndexOutOfBoundsException
   ClassCastException
 3.异常分类   

 public class Test01Exception {
     public static void main(String[] args) {
         //错误Error
        /* int[] arr = new int[999999999];
         System.out.println(arr.length);*/
 ​
        //异常->运行时期异常
         int[] arr = new int[5];
         System.out.println(arr[4]);
         
         //异常-> 编译时期异常
         //FileInputStream fis = new FileInputStream("day11\1.txt");
     }
 }
 ​

2.异常出现的过程

3.创建异常对象(了解)

 1.格式:
   throw new 异常对象()

 public class Test03Exception {
     public static void main(String[] args) {
         String s = "abc.txt";
         method(s);
     }
 ​
     public static void method(String s) {
       if (s.endsWith("txt")){
           //声明异常对象
           throw new NullPointerException();
       }
 ​
         System.out.println("哈哈哈哈哈哈哈");
     }
 }

4.异常处理方式(重点)

4.1 异常处理方式一_throws

 1.格式:参数后面,方法的大括号前面
       throws 异常对象

 public class Test04Exception {
     public static void main(String[] args)throws FileNotFoundException {
         String s = "abc.txta";
         add(s);
 ​
         System.out.println("删除功能");
     }
 ​
     private static void add(String s)throws FileNotFoundException{
         if (!s.endsWith("txt")){
             /*
               创建异常对象
 ​
               我们创建的异常对象属于编译时期异常,所以已出现就爆红了
              */
             throw new FileNotFoundException("文件找不到");
         }
 ​
         System.out.println("hiahiahia");
     }
 ​
 }

4.2 异常处理方式一_throws多个异常

 1.格式:
   throws 异常对象,异常对象...
 2.注意:
   a.如果方法中同时有多个异常,并且多个异常之间有子父类继承关系,先抛小的,再抛大的
   b.如果方法中的多个异常,我们不知道到底是不是子父类继承关系,我们可以直接抛Exception
   

 public class Test05Exception {
     public static void main(String[] args)throws/*throws FileNotFoundException,IOException*/Exception {
         String s = "abc.txta";
         add(s);
 ​
         System.out.println("删除功能");
         System.out.println("修改功能");
         System.out.println("查询功能");
     }
 ​
     private static void add(String s)throws /*IOException,FileNotFoundException*/Exception{
         if (s==null){
             //创建异常对象
             throw new IOException();
         }
 ​
         if (!s.endsWith("txt")){
             /*
               创建异常对象
               我们创建的异常对象属于编译时期异常,所以已出现就爆红了
              */
             throw new FileNotFoundException("文件找不到");
         }
         System.out.println("hiahiahia");
     }
 }
 ​

4.3 异常处理方式二_try...catch

 1.格式
   try{
      可能出现异常的代码
   }catch(异常对象 对象名字){
      处理异常的方案->打印异常信息->将异常信息扔到日志文件中
   }
 ​
 2.注意:
   catch要准确,如果catch不到异常,相当于没有处理,没有处理,就会给jvm,jvm直接结束程序

 public class Test06Exception {
     public static void main(String[] args){
         String s = "abc.txta";
         try {
             add(s);
         } catch (FileNotFoundException e){
               /* printStackTrace打印异常信息->信息很全*/
 ​
             e.printStackTrace();
         }
         System.out.println("删除功能");
         System.out.println("修改功能");
         System.out.println("查询功能");
 ​
     }
 ​
     public static void add(String s) throws FileNotFoundException {
         if (!s.endsWith("txt")) {
             throw new FileNotFoundException("文件找不到");
         }
     }
 }

4.4 异常处理方式二_多个catch

 1.格式:
   try{
     可能出现的异常代码
   }catch(异常对象 对象名){
     处理异常的方案->打印异常信息->将异常信息扔到日志文件中
   }catch(异常对象 对象名){
     处理异常的方案->打印异常信息->将异常信息扔到日志文件中
   }catch(异常对象 对象名){
     处理异常的方案->打印异常信息->将异常信息扔到日志文件中
   }catch(异常对象 对象名){
     处理异常的方案->打印异常信息->将异常信息扔到日志文件中
   }...
       
 2.注意:
   a.如果捕获的多个异常之间,有子父类继承关系,先抓小的,再抓大的异常
   b.如果咱们捕获多个异常时,不知道多个异常之间是否有子父类继承关系,我们可以直接抓大的,或者直接抓Exception

 public class Test07Exception {
     public static void main(String[] args) {
         String s = "abc.txta";
        /* try {
             add(s);
         }catch (FileNotFoundException e){
             e.printStackTrace();
         }catch (IOException e){
             e.printStackTrace();
         }*/
 ​
        /* try {
             add(s);
         } catch (IOException e) {
             e.printStackTrace();
         }*/
 ​
         try {
             add(s);
         } catch (Exception e) {
             e.printStackTrace();
         }
 ​
         System.out.println("删除功能");
         System.out.println("修改功能");
         System.out.println("查询功能");
     }
 ​
     private static void add(String s) throws FileNotFoundException, IOException {
         if (s == null) {
             //创建异常对象
             throw new IOException();
         }
 ​
         if (!s.endsWith("txt")) {
             /*
               创建异常对象
 ​
               我们创建的异常对象属于编译时期异常,所以已出现就爆红了
              */
             throw new FileNotFoundException("文件找不到");
         }
 ​
     }
 }
 ​

快速处理异常快捷键:alt+回车

5.finally关键字

 1.概述:finally中的代码是一定会执行的
 2.格式:
   try{
      可能出现异常的代码
   }catch(异常对象 对象名字){
      处理异常的方案->打印异常信息->将异常信息扔到日志文件中
   }finally{
      一定会执行的代码
   }

 public class Test08Exception {
     public static void main(String[] args){
         String s = "abc.txta";
         try {
             String s1 = null;
             System.out.println(s1.length());//NullPointerException
             add(s);
         } catch (FileNotFoundException e){
               /* printStackTrace打印异常信息->信息很全*/
             e.printStackTrace();
         }finally {
             System.out.println("我一定会执行的.");
         }
 ​
     }
 ​
     public static void add(String s) throws FileNotFoundException {
         if (!s.endsWith("txt")) {
             throw new FileNotFoundException("文件找不到");
         }
     }
 }

 public class Demo08Exception {
     public static void main(String[] args) {
         int result = method();
         System.out.println(result);
     }
 ​
     public static int method() {
         try {
             String s = null;
             System.out.println(s.length());//空指针异常
             return 2;
         } catch (Exception e) {
             return 1;
         } finally {
             System.out.println("我一定要执行");
             //return 3;
         }
 ​
     }
 }

 运行结果:
   我一定要执行
   1
   
 如果finally中加上return 3 执行结果为:
   我一定要执行
   3

finally使用场景:

 关闭资源用:
 像IO流,Socket(网编),数据库连接对象,GC是回收不了的,所以当我们用这些gc回收不了的对象之后,需要手动关闭,所有这些对象使用成不成功都要手动关闭,所以手动关闭的代码就可以放到finally中

6.抛异常时注意的事项

 1.父类中的方法抛异常了,子类重写之后要不要抛?
   可抛可不抛
 2.父类中的方法没有抛异常,子类重写之后要不要抛?
   不要抛

7.try_catch和throws的使用时机

 1.如果处理异常之后,还想让后续的代码正常执行,我们使用try...catch
 2.如果方法之间是递进关系(调用),我们可以先throws,但是到了最后需要用try...catch做一个统一的异常处理

快速处理异常方式:

1.如果遇到编译时期异常:直接alt+回车

2.如果遇到运行时期异常需要处理:选中->ctrl+alt+t

8.自定义异常

 1.模拟用户注册,如果用户已存在,抛出"注册异常""RegisterExcetion"

 public class RegisterExpception extends Exception{
 ​
     public RegisterExpception() {
     }
 ​
     public RegisterExpception(String message) {
         super(message);
     }
 }
 ​

 public class Test {
     public static void main(String[] args) throws RegisterExpception {
         //1.定义一个字符串,表示已经注册的用户名
         String username = "柳岩";
         //2.创建Scanner对象
         Scanner sc = new Scanner(System.in);
         //3.录入一个要注册的信息
         System.out.println("请你输入要注册的用户名:");
         String name = sc.next();
         //4.判断,如果和已存在的username相等,证明注册过,创建异常对象
         if (name.equals(username)){
             //创建异常对象
             throw new RegisterExpception("注册失败");
         }else{
             System.out.println("注册成功");
         }
     }
 }
 ​

总结:

创建一个类,继承Exception,此类是异常类,而且是一个编译时期异常

创建一个类,继承RuntimeException,此类是异常类,而且是一个运行时期异常

想要设置异常信息:提供构造方法

9.打印异常信息的三个方法

 1.Throwable中的方法:
   public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误信息)
   public String toString():获取异常的类型和异常描述信息(不用)
   public void printStackTrace():打印异常的跟踪栈信息并输出到控制台上(最详细的异常信息)

 public class Test01 {
     public static void main(String[] args) {
         String s = "abc.txta";
 ​
         try {
             add(s);
         } catch (Exception e) {
             //public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误信息)
             //System.out.println(e.getMessage());
             //public String toString():获取异常的类型和异常描述信息(不用)
             //System.out.println(e.toString());
 ​
             //public void printStackTrace():打印异常的跟踪栈信息并输出到控制台上(最详细的异常信息)
             e.printStackTrace();
         }
 ​
     }
 ​
     private static void add(String s) throws FileNotFoundException{
 ​
         if (!s.endsWith("txt")) {
             /*
               创建异常对象
 ​
               我们创建的异常对象属于编译时期异常,所以已出现就爆红了
              */
             throw new FileNotFoundException("文件找不到");
         }
 ​
     }
 ​
 }
 ​
 ​

第十五章.设计模式

 1.设计模式:
   代码的一个总结经验

1.模板方法

 模板方法（Template Method）模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
 ​
 饭店中吃饭: 点菜，吃菜和买单三个步骤。点菜和买单基本上一致的，但是吃菜不同，吃法也不同。明确了一部分功能，而另一部分功能不明确。

 public abstract class Hotel {
     public void eat(){
         System.out.println("点菜");
         eatCai();
         System.out.println("扫码买单");
     }
 ​
     //吃菜的方式
     public abstract void eatCai();
 }
 ​
 public class QuanJuDe extends Hotel{
     @Override
     public void eatCai() {
         System.out.println("拿饼");
         System.out.println("放鸭肉,葱,黄瓜,甜面酱");
         System.out.println("卷");
     }
 }
 ​
 public class ZhangLiang extends Hotel{
     @Override
     public void eatCai() {
         System.out.println("麻酱");
         System.out.println("小米辣");
         System.out.println("香菜");
         System.out.println("蒜蓉");
         System.out.println("蚝油");
     }
 }

 public class Test {
     public static void main(String[] args) {
         QuanJuDe quanJuDe = new QuanJuDe();
         quanJuDe.eat();
         System.out.println("----------------------");
         ZhangLiang zhangLiang = new ZhangLiang();
         zhangLiang.eat();
     }
 }

2.工厂设计模式

 简单工厂模式又称静态工厂方法模式。名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

 1.工厂用于造东西的(创建对象),但是不能随便造,不能创造不是一类的东西(对象)
 2.所以,为了防止随便造,达成只能创建一类对象的目的,我们可以定义一个抽象类或者接口
 3.让创建出来的类去继承抽象类或者实现接口
 4.除了子类或者实现类,我们需要一个工厂去专门造对象
 5.创建一个工厂类,定义一个方法,到时候调用这个方法的时候,让我创建啥,我就创建啥
 6.弊端:
     如果调用方法的时候传递了其他的车, createCar()方法就直接报NullPointerException()了
     不想报NullPointerException(),就需要在此方法中加一个判断代码,这样会造成我们反复修改源代码的弊端

 //抽象产品角色
 public interface Car{
     public void drive();
 }
 //具体产品角色
 public class Benz implements Car{
     public void drive() {
         System.out.println("Driving Benz ");
     }
 }
 public class Bmw implements Car{
     public void drive() {
         System.out.println("Driving Bmw ");
     }
 }

 //工厂角色
 public class CarFactory{
     //工厂方法.注意 返回类型为抽象产品角色
     public static Car createCar(String s) {
         //判断逻辑，返回具体的产品角色
         if(s.equalsIgnoreCase("Benz"))
             return new Benz();
         else if(s.equalsIgnoreCase("Bmw"))
             return new Bmw();
         return null;
 }

 public class Magnate{
     public static void main(String[] args){
         Car car = CarFactory.createCar("benz");
         car.drive();
     }
 }

3.工厂方法设计模式

 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

 1.问题:
       从上面的简单工厂代码来看,如果我们调用createCar,传递的不是Benz和Bmw,那么直接就返回空
       再调用drive()方法的时候就报NullPinterException()了
 2.工厂方法就是对简单工厂的延伸
 3.怎么解决呢?
    针对不同的对象,创建不同的工厂.不同的工厂创建不同的对象,我直接不判断了,也就避免了判断有可能失败的问题
 4.好处:
    a.不用像简单工厂那样,调用方法的时候传递参数而造成NullPinterException()了
    b.我们如果传递别的汽车,我就不用像简单工厂那样再加一个判断了(这属于修改源代码,不好)
    b.如果我们想创建别的牌子的车,我们直接再创建一个造此车的工厂,不用修改已经写好的代码了

 public interface Car{
     pubic void driver();
 }
 ​
 public class Benz implements Car{
     public void drive() {
         System.out.println("Driving Benz ");
     }
 }
 ​
 //工厂角色
 public interface Factory{
     public Car createCar();
 }
 //具体工厂角色
 public class BenzFactory implements Factory{
     public Car createCar(){
         return new Benz();
     }
 }
 public class BmFactory  implements Factory{
     public Car createCar() {
         return new Bmw();
     }
 }

 public class Magnate{
     public static void main(String[] args){
         Factory factory = new BenzFactory();
         Car car = factory.createCar();
         car.drive();
     }
 }