JavaSE笔记总结01（封装继承多态，抽象类接口，匿名内部类）

:Concerto

已于 2023-01-07 19:17:44 修改

阅读量610

点赞数

文章标签： java 继承多态

于 2023-01-07 19:08:32 首次发布

本文链接：https://blog.csdn.net/m0_46507516/article/details/128594029

版权

九层之台，起于累土，夯实基础

1 基本

1.1 类

类的成分

修饰符 class 类名{
    // 1.成员变量(Field:描述类和对象的属性信息)
    // 2.成员方法(Method：描述类或者对象的行文信息)
    // 3.构造器(Constructor：初始化一个类的对象并返回引用)
    // 4.代码块
    // 5.内部类
}

构造器

组成

格式：
    修饰符 类名(无参){
}

或者
    修饰符 类名(形参){
}

构造器初始化对象

类名 对象名称 = new 构造器

例子

public class ClassDemo01 {
    public static void main(String[] args) {
        Student s1 = new Student();
    }
}

class Student{

}

1.2 this关键字

作用

    this关键字的作用：
        this代表了当前对象的引用。
        this关键字可以用在实例方法和构造器中
        this用在方法中，谁调用了这个方法，this就是代表了谁
        this用在构造器中，代表了构造器正在初始化的那个对象的引用。

例子

public class ThisDemo2 {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        Animal a2 = new Animal("泰迪",3,'公');
    }
}

class Animal{
    private String name;
    private int age;
    private char sex;


    public Animal() {
    }

    public Animal(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}
//this.name指的是类的属性，后面name表示构造方法的形参

1.3 封装

作用

1.提高安全性
2.可以实现代码的组件化

思想

成员变量私有，提供get和set方法

例子

//封装：属性私有 get/set
        public class Student2 {
            //名字、姓名、学号：一般封装对于属性来说比较多，对于方法少一些
            //学习、睡觉
            private String name;
            private int id;
            private char sex;
            private int age;

            //提供一些可以操作的这个属性的方法：因为上面private了
            //提供一些public的get、set的方法

            //①get获得这个数据
            public String getName() {
                return this.name;
            }

            //②set  给这个数据设置值
            public void setName(String name){
                this.name = name;

            }
            
            //③甚至可以在set里面写if判断来进行安全性检查
            public void setAge(int age) {
                if (age>120 || age<0) {
                    this.age = 3;
                }else{
                    this.age = age;
                }
            }
        }

     public class Application {

            public static void main(String[] args) {       

			Student2 s1 = new Student2();
                
            s1.setName("Sally");
            System.out.println(s1.getName());
                
            s1.setAge(999);
            System.out.println(s1.getAge());
            }
     }

1.4 static关键字

1.区别

  按照有无static区分，区分是类的还是属于对象的，区分如下：
      成员变量
      1.静态成员变量，也叫类变量。属于类本身，与类一起加载，直接用类名调用即可。
      2.实例成员变量，属于类的每个对象，与类的对象一起加载，对象多少，加载多少次，必须用类的对象来访问。

      成员方法
      1.静态方法。属于类本身，属于类的每个对象
      2.实例方法。属于类的每个对象， 必须用类的对象来访问。

成员变量例子

静态成员变量：可在静态成员变量后赋初始值(只有一份)，直接用类名调用即可，同类可以省略类名

实例成员变量：new对象后，用对象访问变量赋予初始值

public class Student {
    //1.定义一个静态成员变量
    public static String schoolName="黑马";
    //2.实例成员变量
    private String name;

    public static void main(String[] args) {
        //1.类名，静态成员变量
        System.out.println(Student.schoolName);
        //注意：同一个类中访问静态成员变量可以省略类名不写
        System.out.println(schoolName);

        //2.对象，实例成员变量
        //System.out.println(Student.name);报错的
        //因此创建一个对象
        Student swk = new Student();
        swk.name = "孙悟空";
        System.out.println(swk.name);

        //3.对象也可以访问静态成员变量(不推荐访问)，因为对象也是属于类本身
        System.out.println(swk.schoolName);

    }
}

成员方法例子

静态方法：使用类去调用，同类中类名可以省略

实例方法：new对象后，使用对象去调用

public class Student {
    //实例成员变量
    private String name;
    private int age;

    //1.静态方法
    public static void inAddr(){
        System.out.println("我们都在天河区");
    }
    //2.实例方法
    //用的实例方法去访问实例变量
    public void eat(){
        System.out.println(this.name+"已经"+age+"岁 在吃好吃的");
    }

    public static void main(String[] args) {
        //3.类名.静态方法
        Student.inAddr();
        //也可以直接,可以省略类不写，直接调用方法名字，只针对静态方法
        inAddr();

        //4.对象方式实例方法
        //Student.eat();报错了
        Student zbj = new Student();
        zbj.name ="猪八戒";
        zbj.age=1000;
        zbj.eat();//调eat方法的时候，zbj去调的，因为有方法中this.name = 刚刚赋值过的猪八戒

        //5.对象访问静态方法(不推荐)
        zbj.inAddr();
    }
}

1.5 代码块

静态代码块：

格式：static{
}
特点：
–必须用static修饰，属于类，会与类一起优先加载，而且自动触发执行一次
–静态代码块可以用于在执行类之前进行静态资源的初始化操作
代码

public class CodeDemo01 {
    public static List<String> cards = new ArrayList<>();
    static {
        System.out.println("静态代码块执行一次");
        cards.add("红桃3");//初始化用的，执行main方法的时候已经初始化两张牌了
        cards.add("红桃4");
    }

    public static void main(String[] args) {
        System.out.println("main方法执行一次");
    }
}

实例代码块

格式：{}
特点：无static，属于类的每个对象的，会和类的每个对象一起加载，每次创建对象的时候，实例代码块就会触发执行一次
作用：可以初始化实例资源
实际上是可以提取到每个构造器中去执行的
代码

public class CodeDemo02 {
    private String name;//实例变量,实例集合都可以
   {
        System.out.println("实例代码块执行一次");
        name = "黑马";//实例化实例变量，每一次创建好对象后都会把名字赋值给到name
    }
    public static void main(String[] args) {
        CodeDemo02 c1 = new CodeDemo02();
        System.out.println(c1.name);
        //或者直接new一个对象,叫做匿名对象，会被gc回收
        new CodeDemo02();
    }
}

1.6 final关键字

特点

final修饰类：类不能被继承了
final修饰方法，方法不能被重写。
final修饰变量，变量有且仅能被赋值一次

final修饰局部变量(代码块、for循环)
final用在方法形参中即使方法体中更改了数值也是无效
final修饰静态成员变量，变量会变成常量

案例

final用在方法形参中即使方法体中更改了数值也是无效

public class FinalDemo2 {
    public static void main(String[] args) {
        int age = 10;
        age = 99;


        final int num = 10;
        //num = 100;//报错了，第二次赋值了

        final double rate = 3.14;//Π是不能变的


        buy(0.8);//买东西8折，会被人家改成1折
        buy(0.9);//外面方法的调用是可以改的
        buy2(0.8);
    }


    public static void buy(double rate){
        rate = 0.1;//被改成1折了
    }
    public static void buy2(final double rate2){
        //rate2=0.1;//改不动

    }
}

常量的用于做信息标志和信息分类

public class EnumDemo02 {

    public static final int UP = 0;
    public static final int DOWN = 1;
    public static final int LEFT = 2;//常量用信息标志
    public static final int RIGHT = 3;//现在直接整形一搞，就能明白什么意思了

    public static void main(String[] args) {
        move(0);//这种可读性比较差，还得点开move看下逻辑
        move1(UP);//可读性就很好，软编码

    }

    //控制玛丽的移动
    public static void move(int oritation) {
        switch (oritation) {
            case 0:
                System.out.println("控制玛丽往上跳~");
                break;
            case 1:
                System.out.println("控制玛丽往下跳~");
                break;
            case 2:
                System.out.println("控制玛丽往左跳~");
                break;
            case 3:
                System.out.println("控制玛丽往右跳~");
                break;
        }
    }


         static void move1(int oritation1){
            switch (oritation1){
                case UP:
                    System.out.println("控制玛丽往上跳~");
                    break;
                case DOWN:
                    System.out.println("控制玛丽往下跳~");
                    break;
                case LEFT:
                    System.out.println("控制玛丽往左跳~");
                    break;
                case RIGHT:
                    System.out.println("控制玛丽往右跳~");
                    break;
            }
    }
}

1.7 内部类

简单内部类

public class InnerClass {//一般外部类不用private修饰

       private class Engine{//内部类爱咋咋地,什么修饰都可以，可以用在需要藏在类中，不允许别人调用，实际开发中还是定义成两个类
           private int age;
    }
}

静态内部类

概念

    什么是静态内部类？
    有static修饰，属于外部类本身，会加载一次

    静态内部类的访问格式：
        外部类名称.内部类名称

    静态内部类创建对象的格式：
        外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器
        
    静态内部类的访问拓展：
        静态内部类中是否可以直接访问外部类的静态成员?可以的宝，因为外部类的静态成员只有一份，可以被共享的！
        静态内部类中是否可以直接访问外部类的实例成员?不可以，实例成员属于对象，直接访问不行，但是可以创造对象访问下·

案例

public class InnerClass {
    public static void main(String[] args) {
        Outter.Inner in = new Outter.Inner();
        in.setName("张三");
        in.setAge(12);
        System.out.println(in.getName());
        System.out.println(in.getAge());
        System.out.println(in);
        in.show();//调普通实例方法也没问题
    }

}


class Outter{
    public static int age1 = 12;
    private double salary;//实例变量
    //静态内部类:有static修饰，属于外部类本身，只加载一次咯
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName = "黑马";

        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 show(){
            System.out.println(name+"-->"+age+"岁~");
            System.out.println(age1);
            //System.out.println(salary);直接访问不行
            Outter o = new Outter();
            System.out.println(o.salary);
        }
    }
}

实例内部类

概念

    什么是实例内部类：
        无static修饰的内部类，属于外部类的每个对象的，跟着对象一起加载。

    实例内部类的成分特点：
        实例内部类中不能定义静态成员，其他都可以定义。
        可以定义常量

    实例内部类的访问格式：
        外部类名称.内部类名称

    创建对象的格式：
        外部类名称.内部类名称 对象名称 = new 外部类构造器.new 内部类构造器;

    拓展：
        实例内部类中是否可以直接访问静态成员？可以的，外部类的静态成员可以被共享访问
        实例内部类中是否可以直接访问外部类的实例成员？可以的,实例内部类属于外部类对象，可以直接访问当前外部类对象的实例成员。

案例

public class InnerClass {
    public static void main(String[] args) {
        //实例内部类属于外部类对象。实例内部类的宿主是外部类对象。所以先外部类出对象再说
            //Outter1.Inner1 in = new Outter1().new Inner1();
            //in.show();
        }
    }

    //外部类
    class outter1{

    public static int age = 1;
    private double salary;//实例变量
    //实例内部类：无static修饰，属于外部类的对象，没有静态区，如果有静态，每次会跟着多个对象一起加载，但是static只能规定加载一次
    public class Inner1{

        //不能在实例内部类中定义静态成员和方法
//        public static String schoolName = "黑马";
//        public static void test(){
//        }
        //但是常量可以
        public static final String schoolName = "黑马";

        private String name;
        //实例方法来一个
        public String getName() {
            return name;
        }

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

        //普通的实例方法
        public void show(){
            System.out.println(age);//实例内部类中是否可以直接访问静态成员
            System.out.println(salary);//实例内部类中是否可以直接访问外部类的实例成员

        }

    }
}

局部内部类

概念

    目标：局部内部类[几乎不用]

    定义在方法中，在构造器中，代码块中，for循环中定义的内部类
    就是局部内部类

    局部内部类中过的成员特点：
        只能定义实例成员，不能定义静态成员
        可以定义常量的

案例

public class InnerClass {

    static {
        abstract class B{

        }
    }

    public static void main(String[] args) {

        class A{
            private String name;
            //public static int age;不能私有，因为这个有的方法可能会调用几百次，那静态也要加载几百次，static只能加载一次，冲突了

            public String getName() {
                return name;
            }

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

            public void test(){

            }

        }
        A a = new A();
        a.test();

    }


    public static void test(){
        class Animal{

        }

        class Cat extends Animal{

        }
    }

}

特殊的局部内部类：匿名内部类

概念

    匿名内部类的格式：
        new 类名/接口类/接口(形参){
            方法重写
         }

    匿名内部类特点：
        1.匿名内部类是一个没有名字的内部类
        2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回,是匿名内部类，也是一个对象呢
        3.匿名内部类的对象的类型相当于是当前new的那个类型的子类类型，就是Cat

案例

public class Anonymity {
    public static void main(String[] args) {
//        Animal a = new Cat();
//        a.run();
//        a.go();

        //直接去new抽象类，然后重写方法，美滋滋
         Animal a = new Animal(){//这边不是代表new了一个抽象类对象，而是匿名内部类的写法，实际也是new了一个Cat

             @Override
             public void run() {
                 System.out.println("猫跑的贼6~~~");
             }
         };

         a.run();
         a.go();
    }

}

//省略子类
//class Cat extends Animal{
//
//    @Override
//    public void run() {
//        System.out.println("猫跑的贼6~~");
//    }
//}

abstract class Animal{
    public abstract void run();

    public void go(){
        System.out.println("开始go~~~");
    }

}

案例2

多个匿名内部类

public class Anomymity02 {

    public static void main(String[] args) {
        Swim boZai = new Swim(){

            @Override
            public void swimming() {
                System.out.println("老师游泳游的贼6~~");
            }
        };
        go(boZai);

        Swim boNiu = new Swim() {
            @Override
            public void swimming() {
                System.out.println("波妞学生游的也不赖");
            }
        };
        go(boNiu);

        //还有更简洁的
        go(new Swim() {
            @Override
            public void swimming() {
                System.out.println("芬芬学生游的也贼6");
            }
        });


    }

    //提供一个方法让全部角色进入比赛
    public static void go(Swim s){
        System.out.println("开始。。。");
        s.swimming();
        System.out.println("结束。。。");
    }

}

//满足会游泳这个规范
interface Swim{
    void swimming();
}

案例3

用在接口上

public class Anomymity03 {
    public static void main(String[] args) {
        //1.创建一个窗口
        JFrame win = new JFrame("登录界面");
        //2.设置窗口的大小
        win.setSize(400,300);
        //3.居中
        win.setLocationRelativeTo(null);
        //4.为当前窗口加上一个按钮对象
        JButton btn = new JButton("开始登录");
        JPanel panel = new JPanel();
        panel.add(btn);
        win.add(panel);
        //5.为当前按钮对象绑定一个点击时间监听器
        btn.addActionListener(new AbstractAction() {//这边看源码需要传入一个接口，直接匿名内部类写了
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("用户点击了触发登录");
            }
        });

        //6.显示窗口
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        win.setVisible(true);
    }
}

1.8 权限修饰符

概念

    四种修饰符的访问权限范围：
                        private  缺省  protected  public
        本类中             T       T       T       T
        本类其他包          F       T       T       T
        其他包中的类        F       F       F       T
        其他包下的子类中     F       F       T       T
                        铜类可 同包别类可  不同包可  同项目可

2 继承

2.1 作用

1.可以提高代码的复用。子类可以继承父类的代码。即可以得到父类的成员变量和成员方法了
2.子类更强大：子类不仅得到了父类的功能，还有自己的功能

2.2 案例

2.2.1 初始案例

person父类

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

    //通用的方法
    public void eat(){
        System.out.println(name+"在吃饭");
    }

    public People() {

    }

    public People(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 Teacher extends People{
    public void teach(){
        System.out.println(getName()+"老师要授课");
    }   
}

应用类

public class TestMain {
    public static void main(String[] args) {
        Teacher boZai = new Teacher();
        boZai.setName("波仔");//调用的是从父类继承的方法
        boZai.setAge(18);
        System.out.println(boZai.getName());//调用的是从父类继承的方法
        System.out.println(boZai.getAge());//调用的是从父类继承的方法
        boZai.eat();//调用的是从父类继承的方法
        boZai.teach();//调用的是自己的方法
    }
}

2.2.2 继承后成员变量的访问特点

可以使用this以及super区分需要的是父类的还是子类的成员变量

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

}

class Animal{
    public String name = "父类名称";

}

class Cat extends Animal{
    public void show(){
        System.out.println(name);//父类的name
    }

}
class Dog extends Animal{
    public String name = "子类名称";
    public void show(){
        String name = "局部名称";
        System.out.println(name);//局部的name，遵循就近原则
        System.out.println(this.name);//子类的name，this代表当前对象
        System.out.println(super.name);//父类名称
        //System.out.println(name2);报错
    }
}

2.2.3 继承后成员方法的访问特点

public class TestDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.run();//子类的方法
        cat.eat();//父类的方法
        //cat.go();//报错
        cat.test();
    }
}

class Animal{
    public void run(){
        System.out.println("动物可以跑");
    }

    public void eat(){
        System.out.println("动物吃东西");
    }

}

class Cat extends Animal{
    public void run(){
        System.out.println("猫跑的贼快");
    }

    public void test(){
        run();  //当前方法
        this.run();//当前方法
        super.run();
    }
}

2.3 方法重写

概念

子类重写一个与父类申请一样的方法来覆盖父类的该方法，子类的这个方法就进行了方法重写
要求：
        1.子类重写方法和形参列表必须和父类被重写方法一样
        2.子类重写方法的返回值类型范围小于等于父类重写的范围，例如子类Integer，父类返回类型Object
        3.子类重写方法的修饰符权限范围大于等于父类重写的范围，例如子类public，父类返回类型protected
        4.子类重写方法的抛出的异常范围小于等于父类重写的范围

例子

public class ExtendsDemo {
    public static void main(String[] args) {
        Wolf w = new Wolf();
        w.run();//就默认不调用父类的方法了，调用了子类的方法
        w.go();
    }
}

class Wolf extends Animal {
    //这样就认为狼进行了方法的重写
    @Override
    public void run() {
        System.out.println("狼跑的贼快~");
    }
    //中转功能
    public void go(){
        run();//能调是因为实例方法调实例方法，这边掉的还是子类的
        super.run();//这边就可以调父类的方法了
    }
}

class Animal{
    public void run(){
        System.out.println("动物可以跑步~");
    }
}

2.4 继承构造器

无参构造器

子类构造器的第一行默认一定会访问父类的无参数构造器(隐藏代码super()，再执行子类自己的构造器

例子

public class TestDemo {
    public static void main(String[] args) {
        Tiger t1 = new Tiger();
    }
}


class Animal {
    public Animal() {
        System.out.println("====父类Animal的无参数构造器=====");
    }
}

class Tiger extends Animal{
    public Tiger() {
        super();//隐藏代码
        System.out.println("====子类Tiger的无参数构造器=====");
    }
}

有参构造器

子类中使用super()去调用父类的有参构造器

public class TestDemo {
    public static void main(String[] args) {
        Monkey monkey = new Monkey("金丝猴",9,'公');
        //但是子类没有有参构造器，根本不可以，因此在子类创建一个super的有参构造
    }

}

class Monkey extends Animal{

    public Monkey(String name, int age, char sex) {
        super(name, age, sex);//送给父类算了，根据参数匹配调用父类构造器
    }

    public void eatBanana(){
        System.out.println(getName()+"-->"+getAge()+"-->"+getSex()+"在吃🍌");
    }

}
class Animal{
    private String name;
    private int age;
    private char sex;

    public Animal() {

    }

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

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

不同构造器的转换

可以使用兄弟构造器进行转换

public class ThisDemo {
    public static void main(String[] args) {
        //需求：希望如果不写学校默认就是”黑马“
        Student zbj = new Student("天蓬元帅",1000);
        System.out.println(zbj.getName());
        System.out.println(zbj.getAge());
        System.out.println(zbj.getSchoolName());

        Student swk = new Student();
    }
}

class Student{
    private String name;
    private int age;
    private String schoolName;


    public Student() {

    }

    public Student(String name, int age) {
        //借用兄弟构造器这个命令,中转作用，但是super和this不能同时使用，不过可以借助完整的兄弟构造器调父类构造器
        this(name,age,"黑马");

    }

    public Student(String name, int age,String schoolName) {
        //super();
        this.name = name;
        this.age = age;
        this.schoolName = schoolName;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return schoolName
     */
    public String getSchoolName() {
        return schoolName;
    }

    /**
     * 设置
     * @param schoolName
     */
    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", schoolName = " + schoolName + "}";
    }
}

2.5 继承的特点

特点

	1.单继承：一个类只能继承一个直接父类
        为什么java是单继承的，回答用反证法，多继承后不知道使用哪个方法 
    2.多层继承：一个类可以间接继承多个父类(家谱)
    例如c可以继承b，b可以继承a
    3.一个类可以有多个子类
    4.一个类要么默认继承了object类，要么间接继承了object类，object类是java的祖宗类

反证法如下

public class ExtendsDemo {
}


class A{
    public void test(){
        System.out.println('A');
    }
}

class B{
    public void test(){
        System.out.println('B');
    }
}

//class C extends B,A{
只能继承一个类呀，不能继承多个类
//    public static void main(String[] args){
//        C c = new C();
//        c.test();//代码运行不下去了，出现了类的二义性
//    }
//}

2.6 引用类型

引用类型作为对象的参数以及返回值

public class TestDemo {
    public static void main(String[] args) {
        Dog jinMao = new Dog();//把地址给到jinMao
        go(jinMao);//jinMao再把地址传给到a变量

        //通过方法调用创建对象
        Dog dog = createDog();

    }

    //引用对象作为方法的返回值,用方法创建对象，牛逼之处是可以直接在方法里初始化对象，然后直接拿对象，数据都有了
    public static Dog createDog(){
        Dog taiDi = new Dog();//new Dog对象后把地址给到taiDi，然后给return，然后给到上面的dog，dog也是指向new Dog这个对象的
        return taiDi;
        //或者精简为return new Dog()

    }

    //提供一个方法让狗进入比赛
    public static void go(Dog a){//对象回调，a变量也是指向new Dog()这个对象的
        System.out.println("开始。。");
        a.run();//a对象还是去调new Dog()的方法
        System.out.println("结束。。");
    }

}


class Dog{
    public void run(){
        System.out.println("狗跑的贼6");
    }
}

引用类型作为成员变量的类型

很常见啦，不写了

3 抽象类

3.1 概述

    小结：抽象类是为了被子类继承，约束子类要重写抽象方法
    一个类继承了抽象类，必须要重写完抽象类的全部，记得是全部的抽象方法，否则这个类也必须定义成抽象类

3.2 例子

public class AbstractDemo {
    public static void main(String[] args) {
        Teacher boZai = new Teacher();
        boZai.work();

        Manager boNiu = new Manager();
        boNiu.work();
    }
}



class Manager extends Employee{

    @Override
    public void work() {
        System.out.println("班主任要管理学生");
    }
}


class Teacher extends Employee{

    @Override
    public void work() {
        System.out.println("老师需要讲课");
    }
}
//需求：一家公司开发员工管理系统(讲师，班主任)

abstract class Employee{
    // 子类都要完成工作这个功能，但是子类工作内容不一样，那么就定义成抽象方法
    public abstract void work();
}

3.3 特征

抽象类本身意味着抽象，抽象是不能具体化的，即不能创建对象

构造器是给子类创建对象调用父类构造器使用的

public class AbstractDemo {
    public static void main(String[] args) {
        //Animal a = new Animal();//不能创建对象

    }
}

abstract class Animal{//可以不写抽象方法
    public abstract void run();

    //也可以有别的方法，作为父类，把重复代码放在里面
    void test() {
    }
}

3.4 设计模式

模板类设计模式

作用

模板设计模式；是经典的设计模式思想。优化代码架构，提高代码的复用性，相同功能的重复代码无需反复书写。
            可是实现部分实现，部分抽象，抽象的东西交给使用模板的人重写实现。

代码

public class AbstractDemo {
    public static void main(String[] args) {


        Student lty = new Student();
        lty.write();

        Teacher zheng = new Teacher();
        zheng.write();
    }
}


//再来一个人用模板
class Teacher extends Template{

    @Override
    public String writeMain() {
        System.out.println("郑老师的正文自由发挥");
        return "\t";
    }
}


class Student extends Template{

    @Override
    public String writeMain() {
        System.out.println("正文自由发挥");
        return "\t";
    }
}

abstract class Template{
    private String title = "《我的爸爸》";
    private String one = "请介绍下你爸爸";
    private String last = "结束";

    public void write(){
        System.out.println(title);
        System.out.println(one);
        System.out.println(writeMain());
        System.out.println(last);
    }

    public abstract String writeMain();

}

单例设计模式

含义

单例的意思是一个类永远只存在一个对象，不能创建多个对象

作用

开发中很多类的对象我们只需要一个，例如虚拟机对象！任务管理器对象；对象越多约占内存，有时候一个对象就能实现业务了，单例可以节约内存，提高性能

分类

1.饿汉单例设计模式：
    -- 通过类获取单例对象的时候，对象已经提前做好了！
    -- 实现步骤：
        1.定义一个单例类
        2.把类的构造器私有
        3.定义一个静态成员变量用于存储一个对象,用的static
        4.定义一个方法返回单例对象
2.懒汉单例设计模式：
    -- 通过类获取单例对象的时候，才去发现没有对象，才会去创建一个对象
    -- 实现步骤：
        1.定义一个单例类
        2.把类的构造器私有
        3.定义一个静态成员变量用于存储一个对象,不能直接创造对象，必须需要的时候才创建
        4.定义一个方法返回单例对象

代码

饿汉单例模式

public class SingleInstanceDemo01 {
    public static void main(String[] args) {
        SingleInstance01 s1 = SingleInstance01.getInstance();//用类名调用静态方法中的getInstance
        SingleInstance01 s2 = SingleInstance01.getInstance();//这两对象应该要是相同的
        System.out.println(s1==s2);
    }
}


//饿汉单例设计模式：
class SingleInstance01 {
    //2.定义一个静态成员变量用于存储一个对象,用的static，因此对象会随类一起加载出来[饿汉单例在返回对象的时候，对象要已经做好了]
    public static SingleInstance01 ins = new SingleInstance01();//把类型改成了SingleInstance01
    //1.把类的构造器私有，构造器只能在本类中访问
    private SingleInstance01(){

    }
    //3.提供方法返回单例对象,返回值类型和对象类型要一致
    public static SingleInstance01 getInstance(){
        return ins;
    }

}

懒汉单例设计模式

public class SingleInstanceDemo02 {
    public static void main(String[] args) {
        SingleInstance02 s1 = SingleInstance02.getInstance();
        SingleInstance02 s2 = SingleInstance02.getInstance();
        System.out.println(s1 == s2);
    }
}


//懒汉单例设计模式：
class SingleInstance02 {
    //2.定义一个静态成员变量用于存储一个对象[懒汉单例他不能直接创建对象，必须需要的时候才创建的]
    public static SingleInstance02 ins;


    //1.构造器私有
    private SingleInstance02(){

    };

    //3.通过方法返回一个对象，不存在对象才创建一个返回
    public static SingleInstance02 getInstance(){
        //return ins;//这样返回就是空啦
        if(ins==null){
            //第一次来取对象，创建一个对象
            ins = new SingleInstance02();
        }
        return ins;
    }
}

4 接口

4.1 概述

修饰符 Interface 接口名称{
	public abstract void run();
    public static final String SCHOOL_NAME = "黑马";
}

4.2 例子

单个接口

public class InterfaceDemo {
    public static void main(String[] args) {
        PingPongMan zjk = new PingPongMan("张继科");
        zjk.run();
        zjk.competition();
    }

}

//实现类实现接口
class PingPongMan implements SportMan{
    private String name;

    //赋值,用有参构造器
    public PingPongMan(String name){
        this.name = name;

    }

    @Override
    public void run() {
        System.out.println(name+"要跑步");

    }

    @Override
    public void competition() {
        System.out.println(name+"要参加比赛");
    }
}

//运动员的接口：规范！
interface SportMan{
    void run();
    void competition();
}

实现多个接口

接口可以多实现

public class InterfaceDemo {
    public static void main(String[] args) {
        //创建实现类对象调用重写的方法执行！
        Basketball yaoMing = new Basketball();
        yaoMing.rule();
        yaoMing.run();
        yaoMing.competition();

    }

}
class  Basketball implements SportMan,Law{

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }

    @Override
    public void rule() {

    }
}

interface SportMan{
    void run();
    void competition();
}


interface Law{
    void rule();//遵纪守法
}

接口继承多个接口

class PingPongMan implements SportMan {

    @Override
    public void run() {

    }

    @Override
    public void competiton() {

    }

    @Override
    public void rule() {

    }

    @Override
    public void abroad() {

    }
}


//现在直接接口继承其他的两个接口
//接口与接口的多继承，用一个接口合并多个接口
//一般公司里正儿八经的没人去写，但是源代码可能会出现，记住语法就可以了
interface SportMan extends Law,Go{
    void run();
    void competiton();
}


interface Law{
    void rule();
}

interface Go{
    void abroad();
}

5 枚举

概念

格式：
        修饰符 enum 枚举名称 {
            实例1名称，实例2名称...；
            
枚举类的特点：
    1.枚举类是final修饰的，不能被继承。
    2.枚举类默认继承了枚举类型：java.lang.Enum
    3.枚举类的第一行罗列的是枚举类对象。而且是用常量存储的。
    4.所以枚举类的第一行写的都是常量名称，默认存储了枚举对象。
    5.枚举类的构造器是私有的。因此对外创建不了对象，对内只提供你写的个对象。
    6.枚举类相当于多例对象。

例子

简单案例

public class EnumDemo01 {
    public static void main(String[] args) {
        Sex s1 = Sex.BOY;//接到boy这个枚举对象,BOY是常量，直接用类名访问了
        System.out.println(s1);//把枚举的地址打出来，但是底层会重写，还是打印值出来
        System.out.println(s1.ordinal());//枚举对象的索引位置0，ordinal是Sex类中继承Enum类的方法
        Sex s2 = Sex.GIRL;
    }

}

//枚举类的格式！
enum Sex{
    BOY,GIRL;
}

常量做信息标志和信息分类,配合枚举类列明信息

enum Oritation{
    UP,DOWN,LEFT,RIGHT;
}
public class EnumDemo03 {
    public static void main(String[] args) {
        move1(Oritation.LEFT);

    }

    public static void move1(Oritation oritation1){//接一个枚举类型
        switch (oritation1){
            case UP:
                System.out.println("控制玛丽往上跳~");
                break;
            case DOWN:
                System.out.println("控制玛丽往下跳~");
                break;
            case LEFT:
                System.out.println("控制玛丽往左跳~");
                break;
            case RIGHT:
                System.out.println("控制玛丽往右跳~");
                break;
        }
    }
}

6 多态

6.1 多态概述

表现

    多态的形式：
        父类类型 对象名称 = new 子类构造器；
        接口    对象名称 = new 实现类构造器；

    多态的识别技巧：
        对于方法的调用：编译看左边，运行看右边
        对于变量的调用：编译看左边，运行看左边

案例

public class PolymorphicDemo {
    public static void main(String[] args) {
        //Cat dlam = new Cat();//以前写的
        //dlam.run();

        Animal dlam = new Cat();//父类类型 对象名称 = new  子类构造器
        dlam.run();

        Animal taiDi = new Dog();
        taiDi.run();


        System.out.println(dlam.name);
        System.out.println(taiDi.name);//打印出来都是动物名称
    }

}


class Dog extends Animal{
    public String name = "狗名称Dog";
    @Override
    public void run(){
        System.out.println("狗跑的贼快");
    }
}

class Cat extends Animal{
    public String name = "猫名称cat";
    @Override
    public void run(){
        System.out.println("猫跑的飞快");
    }
}


class Animal{
    public String name = "动物名称Animal";
    public void run(){
        System.out.println("动物跑！");
    }
}

结果

猫跑的飞快
狗跑的贼快
动物名称Animal
动物名称Animal

6.2 多态优略势

优劣势

    优势：
        1.在多态形势下，右边对象可以实现组件化切换，业务功能也可以随之改变，便于拓展和维护。
            可以实现类与类直接解耦。不希望类与类的关系太紧密。可以随时切换一部分。
            多态只需要更换后面的new后面的类代码即可,目的解耦！
        2.实际开发过程中，父类类型作为方法形式参数，传递子类对象给方法。
            可以传入一切子类对象进行方法的调用，更能体现出多态的拓展性和便利。
    劣势：1.多态形势下，不能直接调用子类特有的功能。编译看左边！左边的父类中没有子类的特有功能，所以代码在编译阶段就直接报错了！

案例

public class PolymorphicDemo {
    public static void main(String[] args) {
        //Cat dlam = new Cat();//以前写的
        //dlam.run();

        Animal dlam = new Cat();//父类类型 对象名称 = new  子类构造器
        dlam.run();

        Animal taiDi = new Dog();
        taiDi.run();
        //taiDi.catMouse();//报错了，多态形式下，编译看左边，左边Animal没有独有功能

        System.out.println(dlam.name);
        System.out.println(taiDi.name);//打印出来都是动物名称


        //2.实际开发过程中，父类类型作为方法形式参数，传递子类对象给方法。
        //但是只能狗进去
//        Dog taidi = new Dog();
//        go(taidi);
          Animal taidi = new Dog();
          go(taidi);

        //猫就进不去了
//        Cat tom = new Cat();
          Animal tom = new Dog();
          go(tom);

    }
        //开发一个游戏 所有动物都可以进来比赛
        //public static void go(Dog d){
        public static void go(Animal d){
            System.out.println("开始");
            d.run();
            System.out.println("结束");
        }

}
class Dog extends Animal{
    public String name = "狗名称Dog";
    @Override
    public void run(){
        System.out.println("狗跑的贼快");
    }

    //独有功能
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

class Cat extends Animal{
    public String name = "猫名称cat";
    @Override
    public void run(){
        System.out.println("猫跑的飞快");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}


class Animal{
    public String name = "动物名称Animal";
    public void run(){
        System.out.println("动物跑！");
    }
}

6.3 多态引用类型强转

概念

引用类型强制类型转换的语法：
    1.父类类型的变量或者对象必须强制类型转换为子类的变量，才能使用子类中的特有方法，否则报错！

强制类型转换的格式:
    类型 变量名称 = (类型) (对象或者变量)

代码

public class PolymorphicDemo {
    public static void main(String[] args) {
        Animal a = new Wolf();
        a.run();
        //a.catchSheep();//报错

        //1.给他强转，把动物类型的变量a转换成真实的狼类型
         Wolf w = (Wolf) a;
         w.catchSheep();

         //2.多态下类型转换异常的问题研究(重点)
        Animal a1 = new Cat();
        //Wolf w1 = (Wolf)a1;//把猫给了狼，编译阶段没有报错！在运行阶段可能出现ClassCastException类型转换异常

        //强转的时候进行一个判断
        if(a1 instanceof Cat){
            Cat c1 = (Cat) a1;
            c1.catchMouse();
        }else if(a1 instanceof Wolf){
            Wolf w1 = (Wolf)a1;
            w1.catchSheep();
        }
    }
}

class Wolf extends Animal{
    @Override
    public void run() {
        System.out.println("狼跑的贼快");
    }

    public void catchSheep(){
        System.out.println("狼抓羊");
    }

}


class Cat extends Animal{
    @Override
    public void run() {
        System.out.println("猫跑的贼快");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }

}

class Animal{
    public void run(){
        System.out.println("动物可以跑");
    }
}

综合案例

代码

/**
    拓展：面向对象思想设计一个电脑对象，可以接入2个USB设备
        (鼠标，键盘：实现接入，调用独有功能，拔出)

    分析：
        1.提供2个USB设备。(USB设备必须满足：接入和拔出的功能)
        2.定义一个USB的接口(申明USB设备的规范必须是：实现接入和拔出的功能)
        3.开始定义2个真实的实现类代表鼠标和键盘
        4.定义一个电脑类
     */
//4.组装电脑
public class Demo {
    public static void main(String[] args) {
        //①买一部电脑先
        Computer c = new Computer();
        //②买一个鼠标
        USB xiaoMi = new Mouse("小米鼠标");
        c.install(xiaoMi);
        //③买一个键盘
        Keyboard logitech = new Keyboard("logitech键盘");
        c.install(logitech);
    }
}
//3.创建一个电脑
class Computer{
    //提供一个安装USB设备的入口
    public void install(USB usb){//这边USB是通用的，键盘和鼠标都可以，放父类，接口也是一种父类
        //这两方法是规范方法
        usb.connect();

        //独有方法要强转类型
        if (usb instanceof Mouse){
            Mouse m = (Mouse) usb;
            m.dbclick();
        }else if(usb instanceof Keyboard){
            Keyboard k = (Keyboard) usb;
            k.keyDown();
        }
        usb.unconnect();
    }
}

//2.定义2个USB设备：鼠标、键盘
class Mouse implements USB{
    private String name;//商标
    //用传参的形式，构造器

    public Mouse(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name+"成功接入了电脑设备~~~");
    }

    @Override
    public void unconnect() {
        System.out.println(name+"成功拔出了设备~~");

    }

    //独有功能，双击
    public void dbclick(){
        System.out.println(name+"双击了老铁666~~~");
    }

}

class Keyboard implements USB{
    private String name;

    //传参构造器
    public Keyboard(String name) {
        this.name = name;
    }


    @Override
    public void connect() {
        System.out.println(name+"成功接入了电脑设备~~~");
    }

    @Override
    public void unconnect() {
        System.out.println(name+"成功拔出了设备~~");
    }

    public void keyDown(){
        System.out.println(name+"键盘写下了：你来了老弟~~");
    }
}


//1.定义USB的规范，必须要完成接入和拔出的功能!!
interface USB{
    //接入
    void connect();
    //拔出
    void unconnect();
}

结果

小米鼠标成功接入了电脑设备~~~
小米鼠标双击了老铁666~~~
小米鼠标成功拔出了设备~~
logitech键盘成功接入了电脑设备~~~
logitech键盘键盘写下了：你来了老弟~~
logitech键盘成功拔出了设备~~

Process finished with exit code 0