JavaSE进阶（day03，复习自用）

面向对象三大特征之三：多态

多态的概述

什么是多态？
指对象可以有多种形态。

public abstract class Animal {
    public String name = "父类动物";
    public abstract void run();
}

public class Dog extends Animal{

    public String name = "子类狗";
    @Override
    public void run() {
        System.out.println("狗跑得贼溜~~");
    }

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

public class Tortoise extends Animal{
    public String name = "子类乌龟";
    @Override
    public void run() {
        System.out.println("乌龟跑得非常慢！");
    }


    /**
     * 独有功能
     */
    public void layEggs(){
        System.out.println("乌龟在下蛋");
    }
}

/**
 * 目标：认识多态，理解多态的形式和概念
 */
public class Test {
    public static void main(String[] args) {
        //1.多态的形式: 父类类型 对象名称 = new 子类构造器
        Animal a = new Dog();
        a.run();//编译看左边，运行看右边
        System.out.println(a.name);//对于变量的调用：编译看左，运行也看左

        Animal a2 = new Tortoise();
        a2.run();//编译看左边，运行看右边
        System.out.println(a2.name);//对于变量的调用：编译看左，运行也看左

多态的优势

在多态形式下，右边对象可以实现解耦合，便于扩展和维护。
定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。
多态下会产生的一个问题:
多态下不能使用子类的独有功能

public class Test2 {
    public static void main(String[] args) {
        Animal a = new Tortoise();
        go(a);
        Animal a2 = new Dog();
        go(a2);
       // a2.lookDoor();//多态下不能访问子类的独有功能
    }

    /**
     * 要求：所有的动物都可以进来比赛
     */
    public static void go(Animal a){
        System.out.println("开始。。。");
        a.run();
        System.out.println("结束。。。");
    }

多态下: 类型转换问题

引用数据类型的类型转换，有几种方式？
自动类型转换、强制类型转换。
强制类型转换能解决什么问题？
可以转换成真正的子类类型，从而调用子类独有功能。
强制类型转换需要注意什么？
有继承关系/实现的2个类型就可以进行强制转换，编译无问题。
运行时，如果发现强制转换后的类型不是对象真实类型则报错（ClassCastException）
强制类型转换前最好做什么事情，如何进行？
使用instanceof判断当前对象的真实类型，再进行强制转换
对象变量名 instanceof 真实类型

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

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑得很快~~");
    }

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

public class Tortoise extends Animal{
    @Override
    public void run() {
        System.out.println("乌龟跑得非常慢！");
    }

    /**
     * 独有功能
     */
    public void layEggs(){
        System.out.println("乌龟在下蛋~~");
    }
}

/**
 * 目标：学习多态形式下的类中转换机制
 */

public class Test {
    public static void main(String[] args) {
        //自动类型转换：
        Animal a = new Dog();
        a.run();

        //强制类型转换：
        Animal a2 = new Tortoise();
        a2.run();
        
        //Dog d = (Dog) a2;//强制类型转换，编译阶段不报错的（注意：有继承或者实现关系编译阶段可以强制转换，没有毛病）运行时可能出错
        if(a2 instanceof Tortoise){
            Tortoise t = (Tortoise) a2;//从父类类型到子类类型，必须强制类型转换
            t.layEggs();
        }else if (a2 instanceof Dog){
            Dog d = new Dog();
            d.lookDoor();
        }

        System.out.println("--------------------");
        go(new Dog());
        go(new Tortoise());
    }

    public static void go(Animal a){
        a.run();
        //a到底是乌龟还是狗？
        if(a instanceof Tortoise){
            Tortoise t = (Tortoise) a;//从父类类型到子类类型，必须强制类型转换
            t.layEggs();
        }else if (a instanceof Dog){
            Dog d = new Dog();
            d.lookDoor();
        }
    }
}

多态的综合案例

1.定义一个USB的接口（申明USB设备的规范必须是：可以接入和拔出）。
2.提供2个USB实现类代表鼠标和键盘，让其实现USB接口，并分别定义独有功能。
3.创建电脑对象，创建2个USB实现类对象，分别安装到电脑中并触发功能的执行。

/**
 * USB接口 == 规范
 */

public interface USB {
    //接入 拔出
    void connect();
    void unconnect();

}

public class Computer {
    private String name;

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

    public void start(){
        System.out.println(name + "开机了~~");
    }

    /**
     * 提供安装USB设备的入口
     */
    public void installUSB(USB usb){
        //多态:usb == 可能是鼠标，也可能是键盘
        usb.connect();
        //独有功能：先判断，再强转
        if(usb instanceof KeyBoard){
            KeyBoard k = (KeyBoard) usb;
            k.keyDown();
        }else if(usb instanceof Mouse){
            Mouse m = (Mouse) usb;
            m.dbclick();
        }

        usb.unconnect();
    }



    public String getName() {
        return name;
    }

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

/**
 * 实现类
 */

public class KeyBoard implements USB{
    private String name;

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

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

    /**
     * 独有功能
     */
    public void keyDown(){
        System.out.println(name + "敲击了：来了，老弟，666~~~没毛病~~~");
    }


    @Override
    public void unconnect() {
        System.out.println(name + "成功从电脑中拔出了~");
    }

    public String getName() {
        return name;
    }

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

/**
 * 实现类
 */

public class Mouse implements USB{
    private String name;

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

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

    /**
     * 独有功能
     */
    public void dbclick(){
        System.out.println(name + "双击点亮小红心，一键三连~~");
    }


    @Override
    public void unconnect() {
        System.out.println(name + "成功从电脑中拔出了~");
    }

    public String getName() {
        return name;
    }

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

/**
 * 目标：USB设备模拟
 * 1.定义USB接口：接入 拔出
 * 2.定义2个USB的实现类：鼠标，键盘
 * 3.创建一个电脑对象，创建USB设备对象，安装启动
 */

public class Test {
    public static void main(String[] args) {
        //a.创建电脑对象
        Computer c = new Computer("外星人");
        c.start();

        //b.创建鼠标对象，键盘对象
        USB u = new KeyBoard("双飞燕");
        c.installUSB(u);

        USB u1 = new Mouse("罗技");
        c.installUSB(u1);

    }
}

内部类

内部类概述[了解]

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

内部类之一：静态内部类[了解]

1、静态内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、静态内部类中是否可以直接访问外部类的实例成员？
不可以的，外部类的实例成员必须用外部类对象访问。
静态内部类的使用场景、特点、访问总结：
如果一个类中包含了一个完整的成分，如汽车类中的发动机类。
特点、使用与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。
访问总结：可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。
注意：开发中实际上用的还是比较少。

/**
 * 外部类
 */

public class Outer {

    public static int a = 100;
    private String hobby;

    /**
     * 学习静态成员内部类
     */
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName;

        public Inner() {
        }

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

        public void show(){
            System.out.println("名称:" + name);
            System.out.println(a);
            //或者用下面的方式(其实同个类中类名可以不写)
            //System.out.println(Outer.a);


            //System.out.println(hobby);//直接访问会报错，下面间接访问不会报错
//            Outer o = new Outer();
//            System.out.println(o.hobby);
        }


        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 Test {
    public static void main(String[] args) {
        Outer.Inner in  = new Outer.Inner();
        in.setName("张三");
        in.show();
    }
}

内部类之二：成员内部类[了解]

1、成员内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、成员内部类的实例方法中是否可以直接访问外部类的实例成员？
可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员

public class Test2 {
    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }
}

class People{
    private int heartbeat = 150;

    /**
     * 成员内部类的对象变量
     */

    public class Heart{
        private int heartbeat = 110;
        public void show(){
            int heartbeat = 78;
            System.out.println(heartbeat); // 78
            System.out.println(this.heartbeat); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}

内部类之三：局部内部类[了解]

局部内部类 （鸡肋语法，了解即可）
局部内部类放在方法、代码块、构造器等执行体中。
局部内部类的类文件名为： 外部类$N内部类.class。

内部类之四：匿名内部类概述[重点]

/**
 * 目标：学习匿名内部类的形式和特点
 */

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal(){
            @Override
            public void run() {
                System.out.println("老虎跑得快~");
            }
        };
        a.run();
    }
}

abstract class Animal{
    public abstract void run();
}

//class Tiger extends Animal{
//    @Override
//    public void run() {
//        System.out.println("老虎跑得快~");
//    }
//}

匿名内部类常见使用形式

**
 * 目标：掌握匿名内部类的使用形式（语法）
 */

public class Test2 {
    public static void main(String[] args) {
        //Swimming s = new Student();//原本用这个方法
        Swimming s = new Swimming(){
            @Override
            public void swim(){
                System.out.println("学生们快乐的自由泳~~");
            }
        };
        go(s);
        System.out.println("-----------------------");

        go(new Swimming(){
            @Override
            public void swim() {
                System.out.println("运动员游得贼快~");
            }
        });
    }

    /**
     * 学生 老师 运动员可以一起参加游泳比赛
     */
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }

}

//用了匿名内部类之后下面这段就不用了
//class Student implements Swimming{
//    @Override
//    public void swim() {
//        System.out.println("学生们快乐的自由泳~");
//    }
//}

interface Swimming{
    void swim();
}

常用API

API概述

API(Application Programming interface) 应用程序编程接口。
简单来说：就是Java帮我们已经写好的一些方法，我们直接拿过来用就可以了。

Object类：toString方法

Object的toString方法的基本作用是什么，存在的意义是什么？
基本作用：给子类继承，子类对象调用可以返回自己的地址。
意义：让子类重写，以便返回子类对象的内容。

Object类：equals方法

Object的equals方法的基本作用，存在的意义是什么？
基本作用：默认是与另一个对象比较地址是否一样
存在的意义：让子类重写，以便比较对象的内容是否相同。

import java.util.Objects;

public class Student {//extends Object
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

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


    /**
     * 官方代码
     *定制相等规则
     *两个对象的内容一样就认为是相等的
     * s1.equals(s2)
     */

    @Override
    public boolean equals(Object o) {
        //1.判断是否是同一个对象比较，如果是返回true。
        if (this == o) return true;
        //2.如果o是null返回false  如果o不是学生类型返回false
        //下文第一个getClass()前面隐含了一个this
        if (o == null || getClass() != o.getClass()) return false;
        //3.说明o一定是学生类型而且不为null
        Student student = (Student) o;
        //下文第一个sex,age,name前省略了一个this
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }



    /**
     *自己重写equals，自己定制相等规则
     *两个对象的内容一样就认为是相等的
     * s1.equals(s2)
     */
    /*@Override
    public boolean equals(Object o){
        //1.判断o是不是学生类型
        if(o instanceof Student){
            Student s2 = (Student) o;
            //2.判断2个对象的内容是否一样。
//            if(this.name.equals(s2.name) && this.age == s2.age && this.sex == s2.sex){
//                return true;
//            }else{
//                return false;
//            }
            return this.name.equals(s2.name) && this.age == s2.age
                    && this.sex == s2.sex;
        }else{
            //学生只能跟学生比较，否则只能是false
            return false;
        }
    }*/




    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

/**
 * 目标：掌握Object类中toString方法的使用。
 */

public class Test1 {
    public static void main(String[] args) {
        Student s = new Student("周雄",'男',19);
//        String rs = s.toString();
//        System.out.println(rs);
        System.out.println(s.toString());
        //直接输出对象变量，默认可以省略toString调用不写的
        System.out.println(s);

    }
}

运行结果：
Student{name=‘周雄’, sex=男, age=19}
Student{name=‘周雄’, sex=男, age=19}

import java.util.Objects;

/**
 * 目标：掌握Object类中equals方法的调用。
 */

public class Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("周雄",'男',19);
        Student s2 = new Student("周雄",'男',19);
        //equals默认是比较2个对象的地址是否相同
        System.out.println(s1.equals(s2));//但我们重写了equals，是判断里面的内容是否相等
        System.out.println(s1 == s2);

        System.out.println(Objects.equals(s1, s2));

    }
}

运行结果：
true
false
true

Objects

import java.util.Objects;

/**
 * 目标：掌握objects类的常用方法：equals
 */

public class Test {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "itheima";
        //System.out.println(s1.equals(s2));//留下了隐患，可能出现空指针异常
        System.out.println(Objects.equals(s1, s2));//更安全 结果也是对的！

        /*
        public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
        }
         */

        System.out.println("------------------------------");
        System.out.println(Objects.isNull(s1));//true
        System.out.println(s1 == null);//true
        System.out.println(Objects.isNull(s2));//false
        System.out.println(s2 == null);//false



    }

}

StringBuilder

StringBuilder是一个可变的字符串的操作类，我们可以把它看成是一个对象容器。
使用StringBuilder的核心作用：操作字符串的性能比String要更高（如拼接、修改等）。

/**
 * 目标：学会使用StringBuilder操作字符串，最终还需要知道它性能好的原因
 */

public class StringBuilderDemo1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();//""
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(1);
        sb.append(false);
        sb.append(3.3);
        sb.append("abc");
        System.out.println(sb);

        StringBuilder sb1 = new StringBuilder();
        //支持链式编程
        sb1.append("a").append("b").append("c").append("我爱你中国");
        System.out.println(sb1);


        //反转
        sb1.reverse().append("110");
        System.out.println(sb1);

        System.out.println(sb1.length());

        //注意：StringBuilder只是拼接字符串的手段：效率好。
        //最终的目的还是要恢复成String类型。
        StringBuilder sb2 = new StringBuilder();
        sb2.append("123").append("456");
        //恢复成String类型
        String rs = sb2.toString();
        check(rs);

    }

    public static void check(String data){
        System.out.println(data);
    }


}

为什么拼接、反转字符串建议使用StringBuilder?
StringBuilder：内容是可变的、拼接字符串性能好、代码优雅。
String ：内容是不可变的、拼接字符串性能差。

定义字符串使用String
拼接、修改等操作字符串使用StringBuilder

public class StringBuilderTest2 {
    public static void main(String[] args) {
        int[] arr1 = null;
        System.out.println(toString(arr1));

        int[] arr2 = {10,28,99};
        System.out.println(toString(arr2));

    }

    /**
     * 1.定义方法接受任意整型数组，返回数组内容格式
     */
    public static String toString(int[] arr){
        if(arr!=null){
            //2.开始拼接内容
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i==arr.length-1?"":", ");
            }
            sb.append("]");
            return sb.toString();
        }else{
            return null;
        }

    }
}