day13-面向对象进阶（多态、内部类、常用API）
13、面向对象进阶（多态、内部类、常用API）
- 面向对象三大特征之三：多态
-
- 多态的优势
- 多态的案例
- 内部类
-
- 内部类概述
- 内部类之一：静态内部类[了解]
- 内部类之二：成员内部类[了解]
- 内部类之三：局部内部类[了解]
- 内部类之四：匿名内部类概述[重点]
- 匿名内部类常见使用形式
- 匿名内部类真实使用场景演示
- 常用API
-
- Object
-
- toString方法
- equals方法
- Objects
- StringBuilder
- Math
- System
- BigDecimal
面向对象三大特征之三：多态
package com.itheima.d1_polymorphic;
/**
父类
*/
public class Animal {
public String name = "动物名称";
public void run(){
System.out.println("动物可以跑~~");
}
}
package com.itheima.d1_polymorphic;
public class Dog extends Animal{
public String name = "狗名称";
@Override
public void run() {
System.out.println("跑的贼溜~~~~~");
}
}
package com.itheima.d1_polymorphic;
public class Tortoise extends Animal{
public String name = "乌龟名称";
@Override
public void run() {
System.out.println("跑的非常慢~~~");
}
}
package com.itheima.d1_polymorphic;
public class Test {
public static void main(String[] args) {
// 目标：先认识多态的形式
// 父类 对象名称 = new 子类构造器();
Animal a = new Dog();
a.run(); // 方法调用：编译看左，运行看右
System.out.println(a.name); // 方法调用：编译看左，运行也看左，动物名称
Animal a1 = new Dog();
a1.run();
System.out.println(a1.name); // 动物名称
}
}
多态的优势
package d2_polymorphic_advantage;
/**
父类
*/
public class Animal {
public String name = "动物名称";
public void run(){
System.out.println("动物可以跑~~");
}
}
package d2_polymorphic_advantage;
public class Dog extends Animal {
public String name = "狗名称";
@Override
public void run() {
System.out.println("跑的贼溜~~~~~");
}
/**
独有功能
*/
public void lookDoor(){
System.out.println("在看！！！");
}
}
package d2_polymorphic_advantage;
public class Tortoise extends Animal {
public String name = "乌龟名称";
@Override
public void run() {
System.out.println("跑的非常慢~~~");
}
}
package d2_polymorphic_advantage;
public class Test {
public static void main(String[] args) {
Animal d = new Dog();
go(d);
// d.lookDoor();
Animal t = new Tortoise();
go(t);
}
/**
希望这个方法可以接收一切子类动物对象
* @param a
*/
public static void go(Animal a){
System.out.println("预备~~~");
a.run();
System.out.println("结束~~~~");
}
}
package d3_polymorphic_convert;
/**
父类
*/
public class Animal {
public String name = "动物名称";
public void run(){
System.out.println("动物可以跑~~");
}
}
package d3_polymorphic_convert;
public class Dog extends Animal {
public String name = "狗名称";
@Override
public void run() {
System.out.println("跑的贼溜~~~~~");
}
/**
独有功能
*/
public void lookDoor(){
System.out.println("在看！！！");
}
}
package d3_polymorphic_convert;
public class Tortoise extends Animal {
public String name = "乌龟名称";
@Override
public void run() {
System.out.println("跑的非常慢~~~");
}
/**
独有功能
*/
public void layEggs(){
System.out.println("在下蛋~~~");
}
}
package d3_polymorphic_convert;
/**
目标：学习多态形式下的类中转换机制。
*/
public class Test {
public static void main(String[] args) {
// 自动类型转换
Animal a = new Dog();
a.run();
// a.lookDoor(); // 多态下无法调用子类独有功能
// 强制类型转换:可以实现调用子类独有功能的
Dog d = (Dog) a;
d.lookDoor();
// 注意：多态下直接强制类型转换，可能出现类型转换异常
// 规定：有继承或者实现关系的2个类型就可以强制类型转换，运行时可能出现问题。
// Tortoise t1 = (Tortoise) a;
// 建议强制转换前，先判断变量指向对象的真实类型，再强制类型转换。
if(a instanceof Tortoise){
Tortoise t = (Tortoise) a;
t.layEggs();
}else if(a instanceof Dog){
Dog d1 = (Dog) a;
d1.lookDoor();
}
System.out.println("---------------------");
Animal a1 = new Dog();
go(a1);
}
public static void go(Animal a){
System.out.println("预备~~~");
a.run();
// 独有功能
if(a instanceof Tortoise){
Tortoise t = (Tortoise) a;
t.layEggs();
}else if(a instanceof Dog){
Dog d1 = (Dog) a;
d1.lookDoor();
}
System.out.println("结束~~~~");
}
}
多态的案例
package d4_polymorphic_test;
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 d4_polymorphic_test;
/**
实现类（子类）
*/
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 d4_polymorphic_test;
/**
实现类（子类）
*/
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 d4_polymorphic_test;
public interface USB {
void connect();
void unconnect();
}
package d4_polymorphic_test;
/**
目标：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 d5_innerclass_static;
/**
外部类
*/
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(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;
}
}
}
package d5_innerclass_static;
public class Test {
public static void main(String[] args) {
Outer.Inner in = new Outer.Inner();
in.setName("张三");
in.show();
}
}
package d6_innerclass;
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
}
}
}
内部类之二：成员内部类[了解]
package d6_innerclass;
/**
外部类
*/
public class Outer {
public static int num = 111;
private String hobby;
public Outer() {
}
public Outer(String hobby) {
this.hobby = hobby;
}
/**
成员内部类：不能加static修饰 属于外部类对象的
*/
public class Inner{
private String name;
private int age;
public static int a; // JDK 16开始支持静态成员了
//public static void test(){
System.out.println(a);
}
public void show(){
System.out.println("名称：" + name);
System.out.println("数量：" + num);
System.out.println("爱好：" + 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;
}
}
}
package d6_innerclass;
public class Test {
public static void main(String[] args) {
Outer.Inner in = new Outer().new Inner();
in.setName("内部");
in.show();
//Outer.Inner.test();
System.out.println("------------");
Outer.Inner in1 = new Outer("爱听课").new Inner();
in1.show();
}
}
内部类之三：局部内部类[了解]
package d7_innerclass;
/**
目标：了解局部内部类的语法
*/
public class Test {
static {
class Dog{
}
abstract class Animal{
}
interface SportManInter{
}
}
public static void main(String[] args) {
class Cat{
private String name;
public static int onLineNumber = 100;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
interface SportManInter{
}
Cat c = new Cat();
c.setName("叮当猫~");
System.out.println(c.getName());
}
}
内部类之四：匿名内部类概述[重点]
package d8_innerclass_anonymous;
/**
目标：学习匿名内部类的形式和特点。
*/
public class Test {
public static void main(String[] args) {
Animal a = new Animal(){
@Override
public void run() {
System.out.println("老虎跑的块~~~");
}
};
a.run();
}
}
//class Tiger extends Animal{
// @Override
// public void run() {
// System.out.println("老虎跑的块~~~");
// }
//}
abstract class Animal{
public abstract void run();
}
匿名内部类常见使用形式
package d8_innerclass_anonymous;
/**
目标：掌握匿名内部类的使用形式（语法）
*/
public class Test2 {
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();
}
匿名内部类真实使用场景演示
package d8_innerclass_anonymous;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
目标：通过GUI编程 理解匿名内部类的真实使用场景
*/
public class Test3 {
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);
}
}
常用API
Object
toString方法
package d9_api_object;
/**
目标：掌握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);
}
}
package d9_api_object;
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)
比较者：s1 == this
被比较者： s2 ==> o
*/
@Override
public boolean equals(Object o) {
// 1、判断是否是同一个对象比较，如果是返回true。
if (this == o) return true;
// 2、如果o是null返回false 如果o不是学生类型返回false ...Student != ..Pig
if (o == null || this.getClass() != o.getClass()) return false;
// 3、说明o一定是学生类型而且不为null
Student student = (Student) o;
return sex == student.sex && age == student.age && Objects.equals(name, student.name);
}
/**
自己重写equals，自己定制相等规则。
两个对象的内容一样就认为是相等的
s1.equals(s2)
比较者：s1 == this
被比较者： s2 ==> o
*/
/* @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 +
'}';
}
}
equals方法
package d9_api_object;
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));
System.out.println(s1 == s2);
System.out.println(Objects.equals(s1, s2));
}
}
Objects
package d10_api_objects;
import java.util.Objects;
/**
目标：掌握objects类的常用方法:equals
*/
public class Test {
public static void main(String[] args) {
String s1 = null;
String s2 = new String("itheima");
// System.out.println(s1.equals(s2)); // 留下了隐患，可能出现空指针异常。
System.out.println(Objects.equals(s1, s2)); // 更安全，结果也是对的！
/**
Objects：
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
*/
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
package d11_api_stringbuilder;
/**
目标：学会使用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);
}
}
package d11_api_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
package d12_math;
/**
目标：Math类的使用。
Math用于做数学运算。
Math类中的方法全部是静态方法，直接用类名调用即可。
方法：
方法名 说明
public static int abs(int a) 获取参数a的绝对值：
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整
小结：
记住。
*/
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
package d13_system;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.Arrays;
/**
目标：System系统类的使用。
System代表当前系统。（虚拟机系统）
静态方法：
1.public static void exit(int status):终止JVM虚拟机，非0是异常终止。
2.public static long currentTimeMillis():获取当前系统此刻时间毫秒值。(重点)
3.可以做数组的拷贝。
arraycopy(Object var0, int var1, Object var2, int var3, int var4);
* 参数一：原数组
* 参数二：从原数组的哪个位置开始赋值。
* 参数三：目标数组
* 参数四：赋值到目标数组的哪个位置
* 参数五：赋值几个。
*/
public class SystemDemo {
public static void main(String[] args) {
System.out.println("程序开始。。。");
// System.exit(0); // JVM终止！
// 2、计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值。
long time = System.currentTimeMillis();
System.out.println(time);
long startTime = System.currentTimeMillis();
// 进行时间的计算：性能分析
for (int i = 0; i < 100000; i++) {
System.out.println("输出：" + i);
}
long endTime = System.currentTimeMillis();
System.out.println((endTime - startTime)/1000.0 + "s");
// 3、做数组拷贝（了解）
/**
arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length)
参数一：被拷贝的数组
参数二：从哪个索引位置开始拷贝
参数三：复制的目标数组
参数四：粘贴位置
参数五：拷贝元素的个数
*/
int[] arr1 = {10, 20, 30, 40, 50, 60, 70};
int[] arr2 = new int[6]; // [0, 0, 0, 0, 0, 0] ==> [0, 0, 40, 50, 60, 0]
System.arraycopy(arr1, 3, arr2, 2, 3);
System.out.println(Arrays.toString(arr2));
System.out.println("-------------------");
double i = 10.0;
double j = 3.0;
//
// System.out.println(k1);
System.out.println("程序结束。。。。");
}
}
BigDecimal
package d14_bigdecimal;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;
/**
目标：BigDecimal大数据类。
引入：
浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。
BigDecimal可以解决浮点型运算数据失真的问题。
BigDicimal类：
包：java.math.
创建对象的方式（最好的方式：）
public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。
方法声明
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算
public double doubleValue(): 把BigDecimal转换成double类型。
*/
public class BigDecimalDemo {
public static void main(String[] args) {
// 浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。
System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);
System.out.println("-------------------------");
double a = 0.1;
double b = 0.2;
double c = a + b;
System.out.println(c);
System.out.println("--------------------------");
// 包装浮点型数据成为大数据对象 BigDeciaml
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
BigDecimal c1 = a1.add(b1);
// BigDecimal c1 = a1.subtract(b1);
// BigDecimal c1 = a1.multiply(b1);
// BigDecimal c1 = a1.divide(b1);
System.out.println(c1);
// 目的：double
double rs = c1.doubleValue();
System.out.println(rs);
// 注意事项：BigDecimal是一定要精度运算的
BigDecimal a11 = BigDecimal.valueOf(10.0);
BigDecimal b11 = BigDecimal.valueOf(3.0);
/**
参数一：除数 参数二：保留小数位数 参数三：舍入模式
*/
BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 3.3333333333
System.out.println(c11);
System.out.println("-------------------");
}
}
