Day03 多态内部类常用API

今日目标
1 多态
2 内部类
- 2.1 内部类的分类
2.2 成员内部类
2.3 匿名内部类
3 API
3.3 DateFormat类
3.4 Calendar类
3.5 Math类
3.6 System类

# day03复习讨论
## 一多态
1. 多态的三大前提是什么？
有继承/实现关系.
有方法重写.
有父类引用指向子类对象.
```java
```
2. 多态访问成员变量，成员方法的特点是怎样的？
编译看左边（父类），执行看左边（父类）
```java
```
3. 多态的优点是什么，缺点是什么？
提高了程序的扩展性,灵活性
父类可以接受子类对象可以涉及出很多代码

4. 怎么解决多态的缺点？
向下转型

5. 引用数据类型转换有哪些？
向上转型，向下转型

6. 向下转型有什么隐患，怎么解决？
强转前先要判断对象的类型是否可以使用强转的类型接收。
如果被转的引用类型变量，对应的实际类型和目标类型不是同一个类型，那么在转换的时候就会出现ClassCastExcepion异常
需要使用 instanceof 判断语句做类型的判断
关键字 instanceof 就可以用来判断类型

7. 多态在实际的开发中怎样体现？
对象的多态
1. 变量多态 2. 参数多态 3. 返回值多态
方法多态
一个父类有一个方法，子类都去重写。多态访问该方法时，每个子类对象的方法逻辑是不一样的。

## 二内部类
1. 什么是内部类
一个类中定义的另一个类

2. 成员内部类如何实例化对象？
外部类名.内部类名变量=外部类对象.new 内部类构造方法（参数）

3. 成员内部类方法中局部变量，成员变量，外部类成员变量名字冲突了，如何访问？
局部变量：直接访问，
内部类成员变量：this 访问
外部类成员变量：外部类名.this 访问

4. 匿名内部使用有什么前提条件？
有一个父类或者父类接口

5. 匿名内部类的使用场景？
想要快速实现一个抽象类或者抽象方法，就可以使用匿名内部类

6. 匿名内部类的定义格式？
new 类名 / 接口(){
}
如果父类型有抽象方法，需要全部重写

7. 匿名内部类有什么特点？
1.该匿名内部类大括号就是某一个类或者接口的实现类。
2.该格式体现的不仅是一个类，同时还是一个对象

8. 匿名内部类该怎么使用？

使用父类型变量多态接收该匿名子类对象。
直接调用匿名对象定义的新变量
以匿名对象的方式使用

## 三 API
1. Object的特点是是什么？
每个类都把object当做超类，所有对象(包括数组)都实现了这个类的方法

2. Object的toString方法什么功能，怎么重写？
返回该对象的字符串表示
Ait+Insert
3. Object的equals方法什么功能，怎么重写？
比较俩个对象是否相同默认比较的是俩个对象的地址值
Ait+Insert
equsls()and hashCode()

4. Objects的equals方法比较两个对象是否相同有什么好处？
用来直接比较对象中new出来的值的内容数据而不是比较地址值

5. Date类表示什么？
表示日期时间，精确到毫秒

6.如果使用Date类表示当前时间？
Date d1=new Date（）；
System.out.println( d1 );

7. DateFormat类有什么作用？
将日期格式转换成字符串

8. DateFormat类是抽象类，使用时用其子类SimpleDateFormat，创建对象时要指定日期模板。请问年，月，日，时，分，秒，毫秒用什么字母表示
yyyy-MM-dd HH:mm:ss:SS

9. DateFormat中格式化和解析的方法分别是什么？
格式化：
public String format(Date d)
解析：
public Date parse (Strinf s)

10. Math工具类有哪些常用的功能
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

11. System工具类获取当前时间的方法是什么？
currentTimeMillis

多态

什么是多态呢?
同一个对象，在不同时刻表现出来的不同形态
Animal a1=new Cat();
Animal a2=new Dog();
a1.eat(); 猫吃鱼
a2.eat(); 狗吃骨头
Dog Cat都继承Animal
同一种Animal类型的变量a，b 执行相同的方法最后结果不一样这就是多态，在对象里Cat Dog同时都继承了父类，并且对Cat Dog的方法进行了重写而重写后的输出语句会覆盖之前所定义父类的输出语句。

多态的前提和体现
1。有继承/实现关系. extends就是在继承父类
2。有方法重写.
3。有父类引用指向子类对象.
多态基础定义：多态定义方法不可以写静态static
Ctrl+O
继承后子类重写父类
快捷键：
直接写需要重写的方法名就可以跳出来。

第一步：
sex get方法不写需要单独赋值写了可在括号内一起赋值
public class Test1 { // 主类测试类
public static void main(String[] args) {
父类对象接受子类对象
Animal a1=new Cat();
Animal a2=new Dog();
//没有区别
a1.eat();
a2.eat();
}
}
第二步：

public class Animal {
public void eat(){
System.out.println(“动物吃东西”);
}
}
class Cat extends Animal{ //定义Cat继承Animal
@Override
public void eat() { //eat用来重写Animal方法
System.out.println(“猫吃鱼”); //输入新的输出语句
}
}
class Dog extends Animal{ //定义Dog继承Animal
@Override
public void eat() { //eat用来重写Animal方法
System.out.println(“狗吃肉”); }}

多态的成员访问

构造方法：同继承一样，子类会通过 super 访问父类构造方法
/
成员变量：编译看左边（父类），执行看左边（父类）

/////////只会访问父类中定义的变量不会调用别的子类中的变量

1. 多态的格式调用变量 , 指的是使用父类类型调用变量
2. 只去查找父类的变量 , 父类中没有我们要调用的变量 , 那么就会报错

成员方法：编译看左边（父类），执行看右边（子类）

/////////如果子类继承父类方法后没有重写方法那么测试类中就会输出父类方法定义的输出语句。

1. 多态的格式调用方法，指的是使用父类型调用方法。
2. 方法执行时，先执行子类重写的方法，如果子类没有重写，则动态的去父类查找
3. 多态格式调用方法时，只能调用父类型中存在的方法，不能调用子类型中特有的方法（多态的弊端）

多态的好处：提高了程序的扩展性,灵活性
优点：父类可以接受子类对象可以涉及出很多代码

多态形式体现(使用方向)：
1 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的任意子类对象
2 定义方法的时候, 使用父类作为方法的返回值类型 , 该方法可以返回此父类任意子类对象
3 定义变量时 , 用父类类型变量接收子类类型对象
/////////子类定义的特有方法只要使用多态后父类不能调用使用
多态的弊端：不能使用子类的特有功能

多态的定义及显示：

第一步：
public class Animal {
public void eat(){
System.out.println(“动物吃东西”);
}
public void file(){
System.out.println(“动物飞”);
}
}

class Cat extends Animal{ //cat类型的子类方法继承了父类Animal方法

@Override
public void eat() { //对父类方法 eat的重写
System.out.println(“猫吃鱼”);
}
public void catchMouse(){
System.out.println(“抓老鼠”);
}

// 如果子类cat方法中不定义flie这个方法那么在测试类中
访问file方法就会优先使用父类中的file方法输出语句。
// public void file(){
// System.out.println(“长翅膀的猫！！！！”);
// }}

class Dog extends Animal{ //Dog 类型的子类方法继承了父类Animal方法
int age=6;
@Override
public void eat() {
System.out.println(“狗吃肉”);
}
}
class Tiger extends Animal{ //Tiger 类型的子类方法继承了父类Animal方法
@Override
public void eat() {
System.out.println(“老虎吃人”);
}
}
class Birad extends Animal{ //Birad 类型的子类方法继承了父类Animal方法
@Override
public void file() {
System.out.println(“鸟用翅膀飞”);
}
}
class Jingyu extends Animal{
@Override
public void file() {
System.out.println(“鲸鱼在海里游”);
}
}

第二步：
public class Test1 {
public static void main(String[] args) {

Animal a1=new Cat();
//因为猫里面没有飞这个方法所以他会调用父类中的方法
a1.file();//如果定义了 file方法那么就会优先调用子类中的file方法
Animal a2=new Jingyu();
a2.file();
}

多态=========转型

//向上或者向下转型一定要有继承的前提

向上转型：
子类型数据，转换为父类型的数据，就是向上转型。因此多态的书写格式本身就是使用了向上转型。
如：Animal a = new Cat();

向下转型：
父类型的数据转换为子类型数据称为向下转型，和基本数据类型的强转一样
格式 : 目标类型变量名 = (目标类型)(被转换的数据)

向下转型可以解决什么问题？
多态不能访问子类特有方法的问题

Animal k1=new Cat(); //猫的方法转换为Animal父类的方法
Cat k2=(Cat)k1; // 强制转换Animal转为Can类型，实现父类使用子类所定义的方法
k2.catchMouse(); // 可以调用输出子类的方法

例如，
Animal a = new Cat(); // a变量的类型是父类型Animal
Cat c = (Cat) a; // 将Animal父类型的数据转换为子类型Cat

如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现ClassCastException
可以用 instanceof 判断语句做类型的判断即可解决

解决转型的安全隐患：

关键字 : instanceof
/////可以判断一个对象的类型

使用格式：

对象名 instanceof 引用数据类型

通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

向下转型可能产生什么异常，怎么解决？
强转前先要判断对象的类型是否可以使用强转的类型接收。
关键字 instanceof 就可以用来判断类型

接口实现多态
接口中多态的样子：
接口的多态和类继承的多态是一样，前提也是一样的。

多态的应用之处：
第一 : 以多态形式创建一个类的对象
第二 : 方法的参数是一个类或者是一个接口 , 那么我们可以传入子类对象
第三 : 方法的返回值类型是一个类或者接口 , 那么我们可以返回子类对

多态在实际中怎么体现：
对象的多态：
1.变量多态
2.参数多态
3.返回值多态
方法多态：
一个父类有一个方法，多态访问方法是，每个子类对象的逻辑是不一样的。

以父类接受子类方法数据类型的就是多态；

内部类
概念：
一个类A内部定义了一个类B，那么B就是A的内部类。A可以称为外部类。
今天会学习到成员内部类，匿名内部类【常用】

class Outer{ 如果要描述两个事物，这两个事物存在包含关系，
就可以使用成员内部类。
class Inner{ } 人与心的关系；汽车与引擎的关系。
}

成员内部类：

内部类的类型表示：外部类名.内部类名
成员内部类创建对象，需要借助外部类的对象，如下：

内部类实例化对象：
外部类名.内部类名变量 = 外部类对象.new 内部类构造方法(参数)

内部类定义
第一步：

public class Person {
private String name=”布朗尼”;
public class Herat {
int rate = 70;
String name=”詹姆斯”;
public Herat(int rate) {
this.rate = rate;
}
public void beats() {
String name=”Jody”;
System.out.println(this.name+”循环跳动每分钟次数：” + rate);
System.out.println(Person.this.name+”循环跳动每分钟次数：” + rate);
System.out.println(name+”循环跳动每分钟次数：” + rate);

}
}
}
第二步：

public class Test {
public static void main(String[] args) {
外部类名.内部类名变量 = 外部类对象.new 内部类构造方法(参数)
Person.Herat heart =new Person().new Herat(90);
（自己定义的变量）
heart.beats();
}
}

成员内部类方法中局部变量，成员变量，外部类成员变量名字冲突了，如何访问？

局部变量：直接访问，
内部类成员变量：this 访问
外部类成员变量：外部类名.this 访问

匿名内部类
匿名内部类的定义格式:
new 类名 / 接口(){
//如果父类型有抽象方法，需要全部重写
}

特点分析：
1.该匿名内部类大括号就是某一个类或者接口的实现类。
2.该格式体现的不仅是一个类，同时还是一个对象
3.匿名内部类的使用

使用父类型变量多态接收该匿名子类对象。
以匿名对象的方式使用

直接调用方法使用
当做方法的参数传递
当做方法的返回值使用

匿名内部使用前提条件：有一个父类或者父接口
匿名内部类的使用场景：匿名内部类一般用于简化代码，当要快速实现一个抽象类或者接口的抽象方法时，我们就可以使用匿名内部类来简化

匿名内部类有什么特点: 1. 该匿名内部类其实就是某一个类或者接口的子类
2.该格式体现的不仅是一个类，同时还是一个对象

匿名内部类该怎么使用: 1. 使用父类型变量多态接收该匿名子类对象。
2. 一般匿名内部类作为方法的参数传递
3. 方法的返回值

API的学习

object ：是类层次结构的根，每个类都把object当做超类，所有对象(包括数组)都实现了这个类的方法

toString equals 方法的学习：

toString 方法：

IDEA类中 get set方法后右键选择 Generate—toString
功能：将对象转换为字符串形式
执行时机：每次打印对象，或者字符串进行连接时。

equals

功能：比较俩个对象是否相同默认比较的是俩个对象的地址值
this：调用equlas方法的对象，obj是方法传入的对象

equals 方法重写自动生成： equsls()and hashCode()

用来直接比较对象中new出来的值的内容数据而不是比较地址值

如果要输出干净的只有数值的内容那么就需要定义show方法。
这样直接输出定义的变量得到：名字：张三年龄：18 性别：男
public void show() {
System.out.println(“名字：”+name +” 年龄：”+ age+” 性别：” + sex); }
Objects equals：
只是会避免空指针异常，不会重写equals方法

Objects 介绍：
是一个JDK1.7增加的对象工具类，里面都是静态方法，可以用来操作对象。

Date:

作用：表示日期时间，精确到毫秒
java.util.Data包下时间精确到毫秒

直接用无参构造方法创建对象就可以，Date d1=new Date（）；

使用：
构造方法：
Public Date(); 创建对象直接表示当前时间
public Date（long time）：Date对象=1970/1/1 0:0:0 +time毫秒值

DateFormat:

本身是一个抽象类，在创建对象使用的时候，一般使用其子类SimpleDateFormat。
将日期格式转换成字符串：

SimpleDateFormat API:

构造方法：SimpleDateFormat （String pattern）指定日期模板创建日期格式化对象

成员方法：
public String format(Date d) 作用：格式化，将日期对象格式化转化为字符串
日期解析方法： public Date parse (Strinf s)
作用：将字符串转化为日期Date对象。

2020-03-02 15:24:30 yyyy-MM-dd HH:mm:ss:SS

定义格式及使用方法：

public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
test1();
test2();
}
public static void test1() {
Date now = new Date(); //想要输出的格式具体数值用字母代替
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
String format = sdf.format(now);
System.out.println(“format = “ + format);
}

      Thu Mar 03 08:54:46 CST 2022<br />2022年03月03日 08:54:46<br />public class TimeGet {<br />    public static void main(String[] args) throws ParseException {<br />        Date D1=new Date();<br />        System.out.println(D1);<br />SimpleDateFormat s1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");<br />        String STRDate=s1.format(D1);<br />        System.out.println(STRDate);<br />    }<br />}

Date d1=new Date(); //输出提取现在时间
System.out.println(d1);//Wed Mar 02 15:45:23 CST 2022
//getTime 提取精确毫秒时间 52年 18980天455520小时27,331,200分钟1,639,872,000秒
long time = d1.getTime();// 从1970年开始到现在的毫秒↓
System.out.println(“time = “ + time);//time = 1646207123480

Math
工具类
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

Math是什么工具类，有哪些常用的方法？

数学工具类，获取绝对值，向上取整，向下取整，四舍五入，求次幂。

System类获取当前时间的毫秒值方法时那个？

currentTimeMillis

day03-多态 ,内部类,常用API

今日目标

多态
内部类
常用API

1 多态

1.1 面向对象三大特征 ?

封装 , 继承 , 多态

1.2 什么是多态 ?

一个对象在不同时刻体现出来的不同形态
举例 : 一只猫对象
- 我们可以说猫就是猫 : Cat cat = new Cat();
- 我们也可以说猫是动物 : Animal cat = new Cat();
- 这里对象在不同时刻,体现出来的不同形态 , 我们就可以理解为多态

1.3 多态的前提

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

package com.itheima.polymorphism_demo;
/*
    多态的三个前提条件
        1 需要有继承/实现关系
        2 需要有方法重写
        3 父类的引用指向子类的对象
 */
public class AnimalTest {
    public static void main(String[] args) {
        // 3 父类的引用指向子类的对象
        // 多态形式对象
        Animal a = new Cat();
    }
}
class Animal{
    public void eat(){
        System.out.println("吃东西");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼....");
    }
}

1.4 多态的成员访问特点

构造方法 : 和继承一样 , 子类通过super()访问父类的构造方法
成员变量 : 编译看左边(父类) , 执行看左边(父类)
成员方法 : 编译看左边(父类) , 执行看右边(子类)

package com.itheima.polymorphism_demo;
/*
    多态的成员访问特点 :
        1 构造方法 : 和继承一样 , 都是通过super()访问父类的构造方法
        2 成员变量 : 编译看左边(父类) , 执行看左边(父类)
        3 成员方法 : 编译看左边(父类) , 执行看右边(子类) , 注意 , 如果执行时
            1) 子类没有回动态去找父类中的方法
            2) 子类的特有方法无法进行调用(多态的缺点)
 */
public class MemberTest {
    public static void main(String[] args) {
        // 父类的引用指向子类的对象
        Fu f = new Zi();
        // 多态对象调用成员变量
        System.out.println(f.num);
        // 多态对新乡调用调用成员方法
        f.show();
        // 多态对象不能调用子类特有的方法
        // f.show2();
    }
}
class Fu {
    int num = 100;
    public void show() {
        System.out.println("父类的show方法");
    }
}
class Zi extends Fu {
    int num = 10;
    public void show() {
        System.out.println("子类的show方法");
    }
    public void show2(){
        System.out.println("子类特有的方法");
    }
}

1.5 多态的优缺点

优点 : 提高代码的扩展性
缺点 : 不能调用子类特有的功能

package com.itheima.polymorphism_test;
public abstract class Animal {
    private String breed;
    private String color;
    public Animal() {
    }
    public Animal(String breed, String color) {
        this.breed = breed;
        this.color = color;
    }
    public String getBreed() {
        return breed;
    }
    public void setBreed(String breed) {
        this.breed = breed;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public abstract void eat();
}

package com.itheima.polymorphism_test;
public class Cat extends Animal {
    public Cat() {
    }
    public Cat(String breed, String color) {
        super(breed, color);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
    }
    public void catchMouse() {
        System.out.println("抓老鼠...");
    }
}

package com.itheima.polymorphism_test;
public class Dog extends Animal {
    public Dog() {
    }
    public Dog(String breed, String color) {
        super(breed, color);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头!");
    }
    public void lookDoor(){
        System.out.println("狗看门...");
    }
}

package com.itheima.polymorphism_test;
public class Pig extends Animal {
    public Pig() {
    }
    public Pig(String breed, String color) {
        super(breed, color);
    }
    @Override
    public void eat() {
        System.out.println("猪拱白菜...");
    }
    public void sleep() {
        System.out.println("一直再睡...");
    }
}

package com.itheima.polymorphism_test;
/*
    如果方法的参数是一个类的话 , 那么调用此方法需要传入此类的对象 , 或者子类对象
    多态的好处 :
        提高代码的扩展性 , 灵活性
    多态的缺点:
        不能调用子类的特有功能
 */
public class AnimalTest {
    public static void main(String[] args) {
        useAnimal(new Cat());
        System.out.println("---------");
        useAnimal(new Dog());
        System.out.println("---------");
        useAnimal(new Pig());
    }
    public static void useAnimal(Animal a){// Animal a = new Dog()
        a.eat();
        // 多态不能访问子类特有的功能
        // 如果解决 ?
        // 向下转型
        if(a instanceof Cat) {
            Cat cat = (Cat) a;
            cat.catchMouse();
        }
        if(a instanceof Dog) {
            Dog dog = (Dog) a;
            dog.lookDoor();
        }
        if(a instanceof Pig) {
            ((Pig) a).sleep();
        }
    }
//    // 定义一个使用猫类的方法
//    public static void useAnimal(Cat c) {// Cat c = new Cat();
//        c.eat();
//        c.catchMouse();
//    }
//
//    // 定义一个使用狗类的方法
//    public static void useAnimal(Dog d) {// Dog d = new Dog();
//        d.eat();
//        d.lookDoor();
//    }
//
//    // 定义一个使用猪类的方法
//    public static void useAnimal(Pig pig) {
//        pig.eat();
//        pig.sleep();
//    }
}

1.6 多态的转型

向上转型 : 把子类类型数据转成父类类型数据 Animal a = new Cat();
向下转型 : 把父类类型数据转成子类类型数据 Cat cat = (Cat)a;

1.7 多态的转型注意

如果被转的对象 , 对应的实际类型和目标类型不是同一种数据类型 , 那么转换时会出现ClassCastException异常

异常代码如下
public static void main(String[] args) {
Animal a = new Cat();
useAnimal(a);
}
public static void useAnimal(Animal a) {
Dog d = (Dog) a;
d.eat();
}

1.8 解决转型安全隐患

使用关键字 instanceof
作用 : 判断一个对象是否属于一种引用数据类型
格式 : 对象名 instanceof 引用数据类型
- 通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

2 内部类

2.1 内部类的分类

什么是内部类 ?
- 一个A类中定义一个B类 , 那么B类就属于A类的内部类 , A类就属于B类的外部类
什么时候使用内部类 ?
- 多个事物之间有包含关系, 可以使用内部类
内部类分类 ?
- 成员内部类
- 局部内部类
- 匿名内部类

2.2 成员内部类

定义的位置 : 类中方法外
创建成员内部类对象格式 : 外部类名.内部类名对象名 = new 外部类名().new 内部类名(参数);
```java package com.itheima.innerclass_demo.member_innerclass;

// 外部类 public class Person { // 成员内部类 public class Heart { // 频率变量 private int rate; // 跳动方法 public void beats() { System.out.println(“咚咚咚!”); } } }

class Test { public static void main(String[] args) { // 创建内部类对象 Person.Heart heart = new Person().new Heart(); // 调用内部类中的方法 heart.beats(); } }


-   
<a name="d7ab3058"></a>
##### 成员内部类访问外部类的成员
   - 在内部类中有代表外部类对象的格式 : 外部类名的.this  , 私有的也可以访问
   - 外部类要想访问内部类成员 , 需要创建内部类对象
```java
package com.itheima.innerclass_demo.member_innerclass;
public class Person {
    private String name = "张三";
    private int num = 10;
    // 成员内部类
    public class Heart {
        int num = 100;
        // 频率
        private int rate;
        // 跳动
        public void beats() {
            System.out.println("咚咚咚!");
        }
        // 调用外部类的成员
        public void show(){
            int num = 1000;
            System.out.println(Person.this.name);
            System.out.println(num);// 1000 就近原则
            System.out.println(this.num);// 100
            System.out.println(Person.this.num);// 10
        }
    }
}
class Test {
    public static void main(String[] args) {
        Person.Heart heart = new Person().new Heart();
        heart.beats();
        heart.show();
    }
}

2.3 匿名内部类

匿名内部类 : 没有名字的类 , 一次性产品
使用场景 : 如果要简化一个类或者接口的子类时，就可以用
使用方式：直接调用方法 , 作为方法的传参 , 返回值类型
好处 : 简化代码 , 快速实现接口或者抽象的抽象方法
格式 :
```
new 类名/接口名(){  重写抽象方法 }
```
- 注意 : 此处创建的是子类对象!!!
使用方式 :
- 直接调用方法
- 作为方法的参数传递
- 作为方法的返回值类型

//接口
interface Flyable {
    void fly();
}

// 直接调用方法
Flyable f1 = new Flyable() {
    @Override
    public void fly() {
        System.out.println("不知道什么在飞.....");
    }
};
f1.fly();

// 作为方法的参数传递
showFlyable(
    new Flyable() {
        @Override
        public void fly() {
            System.out.println("不知道什么在飞3333");
        }
    }
);
public static void showFlyable(Flyable flyable) {
    flyable.fly();
}

// 作为方法的返回值类型
public static Flyable getFlyable() {
    return new Flyable() {
        @Override
        public void fly() {
            System.out.println("3333333333333");
        }
    };
}

package com.itheima.innerclass_demo.anonymous_innerclass;
/*
    1 如果方法的参数是一个类的话 , 调用此方法需要传入此类的对象或者此类的子类对象
    2 如果方法的返回值类型是一个类的话 , 需要返回此类的对象 , 或者此类的子类对象
     3 如果方法的参数是一个接口的话 , 调用此方法需要传入此接口的实现类对象
     4 如果方法的返回值类型是一个接口的话 , 需要返回此接口的实现类对象
     匿名内部类 : 代表的就是子类对象!!!
        new 类名/接口名(){
            重写抽象类或者接口中的抽象方法
        };
     使用方向 :
        1 调用方法
        2 作为方法参数传递
        3 作为方法的返回值
 */
public interface Swim {
    public abstract void swimming();
}
class Test {
    public static void main(String[] args) {
//        // 子类对象!!!
        //  1 调用方法
//       new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
//            }
//        }.swimming();
//        //   2 作为方法参数传递
//        useSwim(new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
//            }
//        });
//        // 3 作为方法的返回值
//        Swim s = getSwim();
//        s.swimming();
    }
    public static Swim getSwim() {
        return new Swim() {
            @Override
            public void swimming() {
                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
            }
        };
    }
    /*
        Swim swim = new Swim() {
            @Override
            public void swimming() {
                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
            }
        };
     */
    public static void useSwim(Swim swim) {
        swim.swimming();
    }
}

3 API

3.1 Object类

概述 : 类Object是类层次结构的根，每个类都把Object作为超类。所有对象（包括数组）都实现了这个类的方法
方法 : public String toString()
- 如果一个类没有重写toString方法 , 那么打印此类的对象 , 打印的是此对象的地址值
- 如果一个类重写了toString方法 , 那么打印此类的对象 , 打印的是此对象的属性值
- 好处 : 把对象转成字符串 , 快速查看一个对象的属性值
- 执行时机 : 打印对象时会默认调用toString方法
方法 : public boolean equals()
- 如果一个类没有重写equals方法 , 那么比较此类的对象 . 比较的是地址值
- 如果一个类重写了equals方法 . 那么比较此类的对象 , 比较的是属性值是否相等
- 好处 : 可以比较对象的内容

Alt+Insert

3.2 Objects类

Objects是JDK1.7新增的一个对象工具类，里面都是静态方法可以用来操作对象。比如对象的比较，计算对象的hash值，判断对手是否为空….比如里面的equals方法，可以避免空指针异常

public static boolean equals(Object a, Object b):判断两个对象是否相等
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}
a.equals(b) :如果a是null值，肯定会空指针
Objects.equals(a,b);：如果a是null，不会导致空指针异常

3.2 Date类

概述 : java.util.Date 表示特定的瞬间，精确到毫秒
构造方法 :
- public Date(): 创建的对象，表示的是当前计算机系统的时间
- public Date(long time): Date对象 = 1970/1/1 0:0:0 + time毫秒值
成员方法 :
- public long getTime(): 返回毫秒值 = 当前Date代表的时间 - 1970/1/1 0:0:0
- public void setTime(long t): Date对象 = 1970/1/1 0:0:0 + time毫秒值

package com.itheima.api_demo.date_demo;
import java.util.Date;
/*
    Date类 : 代表的是一个瞬间 , 精确到毫秒
    构造方法 :
        public Date() : 代表的是当前系统时间
        public Date(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
    成员方法 :
        public void setTime(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
        public long getTime() : 返回的是毫秒值 = Date代表的时间 - 1970/1/1 0:0:0
 */
public class DateDemo {
    public static void main(String[] args) {
        //  public Date() : 代表的是当前系统时间
//        Date d = new Date();
//        System.out.println(d);
        //  public Date(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
//        Date d2 = new Date(1000L * 60 * 60 * 24); // 1970/1/1 0:0:0 + 一天的毫秒值
//        System.out.println(d2);
        Date d = new Date();
        // public void setTime(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
        // d.setTime(1000L * 60 * 60 * 24);
        System.out.println(d);
        // public long getTime() : 返回的是毫秒值 = Date代表的时间 - 1970/1/1 0:0:0
        // System.out.println(d.getTime());
    }
}

3.3 DateFormat类

概述 : 主要用于操作日期格式的一个类
作用 :
- 格式化 : Date —> String
- 解析 : String —> Date
构造方法 :
- SimpleDateFormat(String pattern) 给定日期模板创建日期格式化对象
成员方法 :
- public String format ( Date d )：格式化，将日期对象格式化为字符串
- public Date parse ( String s )：解析，将字符串解析为日期对象

package com.itheima.api_demo.dateformat_demo;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
    SimpleDateFormat类 :
        "2021年04月03日 16:48:10"  ---> Date
        Date(Sat Apr 03 16:41:38 CST 2021) --> "2021年04月03日 16:48:10"
        作用 :
            格式化 : Date --> String
            解析   : String --> Date
        构造方法 :
            public SimpleDateFormat(String pattern) : pattern : 字符串类型的日期模板
        成员方法 ;
            public final String format(Date date) : 接收一个Date对象返回指定模式的字符串
            public Date parse(String source) : 接收一个字符串  , 返回一个Date对象
        1 获取当前的日期对象，使用格式：yyyy-MM-dd HH:mm:ss 来表示，例如：2020-10-31 17:00:00【格式化】
        2 将字符串的 2020年10月31日  17:00:00，转换为日期Date对象。【解析】
 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        // 解析   : String --> Date
        String strDate = "2020年10月31日 17:00:00";
        // 注意 : 解析时 , SimpleDateFormat的参数(日期模板) , 必须和要解析字符串的模式匹配
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //  public Date parse(String source) : 接收一个字符串  , 返回一个Date对象
        Date date = sdf.parse(strDate);
        System.out.println(date); // Sat Oct 31 17:00:00 CST 2020
    }
    private static void method() {
        // 格式化 : Date --> String
        // 获取当前系统时间
        Date date = new Date();
        // System.out.println(date);// Sat Apr 03 16:53:35 CST 2021
        // public SimpleDateFormat(String pattern) : pattern : 字符串类型的日期模板
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // public final String format(Date date) : 接收一个Date对象返回指定模式的字符串
        String strDate = sdf.format(date);
        System.out.println(strDate);
    }
}

3.4 Calendar类

概述 :
- java.util.Calendar类表示日历，内含有各种时间信息，以及获取，计算时间的方法。
- Calendar本身是一个抽象类，可以通过Calendar提供的静态方法getInstance日历子类对象
Calendar常用方法 :
| 方法名 | 说明 | | —- | —- | | public static Calendar getInstance() | 获取一个它的子类GregorianCalendar对象。 | | public int get(int field) | 获取指定日历字段的时间值。 | | public void set(int field,int value) | 设置指定字段的时间值 | | public void add(int field,int amount) | 为某个字段增加/减少指定的值 |
get,set,add方法参数中都有一个整数类型的参数field，field用来区分当前要获取或者操作的日期时间数据的。field数据的值使用Calender中定义的整数常量来表示
- Calendar.YEAR : 年
- Calendar.MONTH ：月
- Calendar.DAY_OF_MONTH：月中的周
- Calendar.HOUR：小时
- Calendar.MINUTE：分钟，
- Calendar.SECOND：秒
- Calendar.DAY_OF_WEEK：星期
字段时间值 : 1 2 3 … 7
真正的时间 : SUNDAY MONDAY TUESDAY … SATURDAY

星期对应的关系
字段时间值 : 0 1 …. 11
正真的时间 : JANUARY FEBRUARY …. DECEMBER

月份对应的关系

package com.itheima.api_demo.calendar_demo;
/*
    月份对应的关系
    字段时间值     :       0           1           ....        11
    正真的时间     :     JANUARY     FEBRUARY      ....      DECEMBER
 */
import java.util.Calendar;
/*
    成员方法 :
        public int get(int field)    获取指定日历字段的时间值。
        public void set(int field,int value)    设置指定字段的时间值
        public void add(int field,int amount)    为某个字段增加/减少指定的值
 */
public class CalendarDemo {
    public static void main(String[] args) {
        // 获取Calendar对象 , rightNow对象
        Calendar rightNow = Calendar.getInstance();
        // public void set(int field , int value)    设置指定字段的时间值
        // rightNow.set(Calendar.YEAR , 2024);
        // rightNow.set(Calendar.MONTH , 5);
        // rightNow.set(Calendar.DAY_OF_MONTH, 10);
        // public void add(int field,int amount)    为某个字段增加/减少指定的值
        // rightNow.add(Calendar.DAY_OF_MONTH , -3);
        //  public int get(int field)     : 获取指定日历字段的时间值。
        int year = rightNow.get(Calendar.YEAR);
        int month = rightNow.get(Calendar.MONTH);
        int day = rightNow.get(Calendar.DAY_OF_MONTH);
        System.out.println(year); // 2021
        System.out.println(month);// 3
        System.out.println(day);  // 3
    }
}

package com.itheima.api_demo.calendar_demo;
import java.util.Calendar;
/*
    1 写代码使用get方法，将年，月，日，时，分，秒，周获取出来
    特别注意获取月份，和星期有以下特点：
    直接获取的月份数据是从0开始的， 0表示1月，.....11表示12月
    周的获取，从周日开始计算，1就是周日，2就是周一 ......7就是周六
星期对应的关系
     字段时间值  :   1           2            3          ...        7
     真正的时间  : SUNDAY        MONDAY      TUESDAY     ...        SATURDAY
月份对应的关系
    字段时间值     :       0           1           ....        11
    正真的时间     :     JANUARY     FEBRUARY      ....      DECEMBER
 */
public class Test1 {
    public static void main(String[] args) {
        // 拿到当前时间
        Calendar now = Calendar.getInstance();
        System.out.println(now.get(Calendar.YEAR));
        System.out.println(now.get(Calendar.MONTH));
        System.out.println(now.get(Calendar.DAY_OF_MONTH));
        System.out.println(now.get(Calendar.HOUR));
        System.out.println(now.get(Calendar.MINUTE));
        System.out.println(now.get(Calendar.SECOND));
        int week = now.get(Calendar.DAY_OF_WEEK);// 7
        System.out.println(getWeek(week));// 字段值
    }
    public static String getWeek(int field){
        String[] str = { "" , "SUNDAY" , "MONDAY" , "TUESDAY" , "WEDNESDAY" , "THURSDAY" , "FRIDAY" , "SATURDAY"};
        return str[field];
    }
}

package com.itheima.api_demo.calendar_demo;
import java.util.Calendar;
/*
    2 写代码实现，获取2022年10月1日是星期几？
    参考思路：
    直接获取日历对象，得到的是当前系统的日历时间信息。
    获取日历对象后，要重新设置日期
    再获取星期数据
 */
public class Test2 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2022);
        cal.set(Calendar.MONTH, 9);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        int week = cal.get(Calendar.DAY_OF_WEEK);
        System.out.println(getWeek(week));// 字段值
    }
    public static String getWeek(int field){
        String[] str = { "" , "SUNDAY" , "MONDAY" , "TUESDAY" , "WEDNESDAY" , "THURSDAY" , "FRIDAY" , "SATURDAY"};
        return str[field];
    }
}

package com.itheima.api_demo.calendar_demo;
import java.util.Calendar;
/*
    3 计算10000天之后的年月日
    参考思路：
    先获取当前日历对象
    再调用add方法，指定DATE或者DAY_OF_MONTH，添加10000天
    再获取日历的年，月，日
 */
public class Test3 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, 10000);
        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DAY_OF_MONTH));
    }
}

3.5 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) | 四舍五入取整 |

3.6 System类

System类包含几个有用的类字段和方法。它不能被实例化
常用方法 :
| 方法名 | 说明 | | —- | —- | | public static void exit(int status) | 终止当前运行的 Java 虚拟机，非零表示异常终止 | | public static long currentTimeMillis() | 返回当前时间(以毫秒为单位) |

Day03 多态 内部类 常用API

今日目标

多态

内部类

常用API

1 多态

1.1 面向对象三大特征 ?

1.2 什么是多态 ?

1.3 多态的前提

1.4 多态的成员访问特点

1.5 多态的优缺点

1.6 多态的转型

1.7 多态的转型注意

1.8 解决转型安全隐患

2 内部类

2.1 内部类的分类

什么是内部类 ?

什么时候使用内部类 ?

内部类分类 ?

2.2 成员内部类

2.3 匿名内部类

3 API

3.1 Object类

3.2 Objects类

3.2 Date类

概述 : java.util.Date 表示特定的瞬间，精确到毫秒

构造方法 :

成员方法 :

3.3 DateFormat类

3.4 Calendar类

概述 :

Calendar常用方法 :

星期对应的关系

月份对应的关系

3.5 Math类

3.6 System类