Java - day12 - 面向对象进阶 - 多态、内部类、常用API

什么是多态?

• 同类型的对象，执行同一个行为，会表现出不同的行为特征。

多态的常见形式

* 父类类型对象名称 = new 子类构造器;
* 接口对象名称 = new 实现类构造器;

多态中成员访问特点

• 方法调用:编译看左边，运行看右边。
• 变量调用:编译看左边，运行也看左边。(多态侧重行为多态)

多态的前提

• 有继承/实现关系;有父类引用指向子类对象;有方法重写。

优势

• 在多态形式下，右边对象可以实现解耦合，便于扩展和维护。

  Animal a = new Dog();
  a.run();//后续业务行为随对象而变，后续代码无需修改
  

• 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象,体现出多态的扩展性与便利。

多态下会产生的一个问题:

• 多态下不能使用子类的独有功能

多态下引用数据类型的类型转换

自动类型转换（从子到父):子类对象赋值给父类类型的变量指向。

强制类型转换（从父到子)

• 此时必须进行强制类型转换:子类对象变量 = (子类) 父类类型的变量
• 作用:可以解决多态下的劣势，可以实现调用子类独有的功能。

• 注意:如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException。

  Animal t = new Tortoise();
  Dog d = (Dog)t; //出现异常ClassCastException
  

• Java建议强转转换前使用instanceof判断当前对象的真实类型，再进行强制转换
• 变量名 instanceof 真实类型
• 判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之。

实例：

package keyboard;

public class Computer {
    /**
       提供一个安装的入口：行为。
     */
    public void installUSB(USB u){
        u.connect();

        // 独有功能
        if(u instanceof Mouse){
            Mouse m = (Mouse) u;
            m.click();
        }else if(u instanceof KeyBoard) {
            KeyBoard k = (KeyBoard) u;
            k.keyDown();
        }

        u.unconnect();
    }
}

package keyboard;

/**
   实现类（子类）
 */
public 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 + "写下了：老铁，6666，下次再来哦，老弟~~~~");
    }

    public String getName() {
        return name;
    }

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

package keyboard;

/**
   实现类（子类）
 */
public 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 click(){
        System.out.println(name + "双击点亮小红心~~~~");
    }

    public String getName() {
        return name;
    }

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

package keyboard;

/**
    目标：USB设备模拟
    1、定义USB接口：接入 拔出
    2、定义2个USB的实现类：鼠标、键盘。
    3、创建一个电脑对象，创建USB设备对象，安装启动。
 */
public class Test {
    public static void main(String[] args) {
        // a、创建电脑对象
        Computer c = new Computer();
        // b、创建USB设备对象
        USB u = new Mouse("罗技鼠标");
        c.installUSB(u);

        USB k = new KeyBoard("双飞燕键盘");
        c.installUSB(k);
    }

}

package keyboard;

public interface USB {
    void connect();
    void unconnect();
}

内部类

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

public class People{
//内部类
       public class Heart{
   }
}

内部类的使用场景、作用

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
• 内部类通常可以方便访问外部类的成员，包括私有的成员。
• 内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。

内部类的分类

• 静态内部类 [了解]
• 成员内部类（非静态内部类）[了解]
• 局部内部类 [了解]
• 匿名内部类 [重点]

什么是静态内部类?

• 有static修饰，属于外部类本身。
• 它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。
• 注意:开发中实际上用的还是比较少。

public class Outer{
//静态成员内部类
public static class Inner{
    }
}

静态内部类的访问拓展:

1、静态内部类中是否可以直接访问外部类的静态成员?

• 可以，外部类的静态成员只有一份可以被共享访问。

2、静态内部类中是否可以直接访问外部类的实例成员?

• 不可以的，外部类的实例成员必须用外部类对象访问。

什么是成员内部类?

• 无static修饰，属于外部类的对象。
• JDK16之前，成员内部类中不能定义静态成员，JDK 16开始也可以定义静态成员了。

public class outer {
   //成员内部类
       public class Inner {
    }
}

成员内部类创建对象的格式:

• 格式:外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();
• 范例:Outer.Inner in = new Outer().new Inner();

成员内部类的访问拓展:

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 匿名 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳‍");
            }
        };
        go(s);

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

        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师贼快~~~~~");
            }
        };
        go(s1);

        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("结束。。。");
    }
}


interface Swimming{
    void swim();
}

使用总结

• 开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。
• 匿名内部类的代码可以实现代码进一步的简化(回扣主题)

实例：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 目标：通过GUI编程 理解匿名内部类的真实使用场景
 */
public class gui {
    public static void main(String[] args) {
        // 1、创建窗口
        JFrame win = new JFrame("登录界面");
        JPanel panel = new JPanel();
        win.add(panel);

        // 2、创建一个按钮对象
        JButton btn = new JButton("登录");

        // 注意：讲解匿名内部类的使用
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(win, "点我一下，说明爱我！");
            }
        });

//        btn.addActionListener( e ->  JOptionPane.showMessageDialog(win, "别说话，吻我！！") );


        // 3、把按钮对象添加到桌布上展示
        panel.add(btn);

        // 4、展示窗口
        win.setSize(400, 300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);

    }
}

Object类的作用:

• 一个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类。
• object类的方法是一切子类都可以直接使用的，所以我们要学习Object类的方法。

Object类的常用方法:

• public String toString() —— 默认是返回当前对象在堆内存中的地址信息:类的全限名@内存地址。
• public Boolean equals(Object o) —— 默认是比较当前对象与另一个对象的地址是否相同，相同返回true，不同返回false。

Object的toString方法的作用是什么?

• 默认是打印当前对象的地址。
• 让子类重写，以便返回子类对象的内容。

equals存在的意义

• 父类equals方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则。

Object的equals方法的作用是什么?

• 默认是与另一个对象比较地址是否一样
• 让子类重写，以便比较2个子类对象的内容是否相同。

StringBuilder 概述

• StringBuilder是一个可变的字符串类，我们可以把它看成是一个对象容器。
• 作用: 提高字符串的操作效率，如拼接、修改等。

StringBuilder 构造器

• public StringBuilder() —— 创建一个空白的可变的字符串对象，不包含任何内容
• public StringBuilder(String str) —— 创建一个指定字符串内容的可变字符串对象
• 

为什么拼接、反转字符串建议使用StringBuilder?

• String:内容是不可变的、拼接字符串性能差。
• StringBuilder:内容是可变的、拼接字符串性能好、代码优雅。
• 定义字符串使用String。
• 拼接、修改等操作字符串使用StringBuilder。
• 
  实例：

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

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

        int[] arr3 = {};
        System.out.println(toString(arr3));
    }

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

Math类

• 包含执行基本数字运算的方法，Math类没有提供公开的构造器。
• 如何使用类中的成员呢? 看类的成员是否都是静态的，如果是，通过类名就可以直接调用。
• 
  实例：

public class MathDemo {
    public static void main(String[] args) {
        // 1.取绝对值:返回正数
        System.out.println(Math.abs(10)); // 10
        System.out.println(Math.abs(-10.3)); // 10.3

        // 2.向上取整: 5
        System.out.println(Math.ceil(4.00000001)); // 5.0
        System.out.println(Math.ceil(4.0)); // 4.0
        // 3.向下取整：4
        System.out.println(Math.floor(4.99999999)); // 4.0
        System.out.println(Math.floor(4.0)); // 4.0

        // 4.求指数次方
        System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0
        // 5.四舍五入 10
        System.out.println(Math.round(4.49999)); // 4
        System.out.println(Math.round(4.500001)); // 5

        System.out.println(Math.random());  // 0.0 - 1.0 （包前不包后）

        // 拓展： 3 - 9 之间的随机数  （0 - 6） + 3
        //  [0 - 6] + 3
        int data =  (int)(Math.random() * 7) + 3;
        System.out.println(data);
    }
}

System类概述

• System的功能是通用的，都是直接用类名调用即可，所以System不能被实例化。
• 

BigDecimal

• 作用:用于解决浮点型运算精度失真的问题。
• 

BigDecimal的对象如何获取?

• BigDecimal b1 = BigDecimal.valueof(0.1);