13、面向对象进阶(多态、内部类、常用API)
面向对象三大特征之三:多态
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("-------------------");
}
}