java Math、Object类 、多态

Math对象

数学函数类，类是最终类不能被继承，其中的方法都是静态方法，类名直接调用即可

/**
 * ceil()               求大于或等于给定值的最小整数  向上取
 * floor()              求小于或等于给定值的最大整数  向下取
 * random()             生成一个0~1之间的小数
 */
public class MathDemo {
​
    public static void main(String[] args) {
        System.out.println("圆周率："+Math.PI);
        System.out.println("向上取："+Math.ceil(11.5));
        System.out.println("向下取："+Math.floor(-11.5));
        System.out.println("随机数："+Math.random());
        System.out.println("1~10:"+Math.random()*10+1);
        System.out.println("1~10:"+Math.ceil(Math.random()*10));
        System.out.println("0~9:"+Math.floor(Math.random()*10));
        
        String[] nameArrs = {"乔帮主","王公子","史老板"};
        int index = (int) Math.floor(Math.random()*nameArrs.length);
        System.out.println(index+","+nameArrs[index]);
    }
}

Object类

该类为所有类的超类，默认是省略的

面试题：Object中都有哪些方法

hashCode() 通常用于表示某个对象的地址 判断对象是否相同

==比较基本数据类型时比较的是数值，如果是比较引用数据类型，那么比较的是地址

toString() 将类的信息以字符串的形式表示出来

通常开发者会输入对象，为了能够更加快速清晰的知道该对象中的属性的值分别都是什么，此时就会重写该类的toString 方法

直白点说：toString方法是系统提供的一种输出格式

@Override
public String toString() {
    return "User [uid=" + uid + ", username=" + username + ", password=" + password + "]";
}
User user = new User();
System.out.println(user.hashCode());
​
User user2 = user;
​
System.out.println(user2.hashCode());
System.out.println(user);
User user3 = new User("哈哈","123");
/*String username = user3.getUsername();
String password = user3.getPassword();
System.out.println(username+"-"+password);*/
System.out.println(user3);
//toString方法时默认自动调用的，其实真正的写法是：user3.toString()
​
System.out.println("-------------");
System.out.println(user.equals(user2));//true
System.out.println(user.equals(user3));//false
//Object中的equals方法也是通过==进行比较的，注意看源码

13 多态

字面意思：多种形态

多态要求：必须是有继承或实现的关系，(而且有方法重写)

public class Cat extends CatKinds{
    public void eatFish(){
        System.out.println("猫吃鱼");
    }
}
​
public class Tiger extends CatKinds{
    public void king(){
        System.out.println("大王");
    }
}
​
public class CatKinds extends Animal{
    public void sleep(){
        System.out.println("猫科动物会睡觉");
    }
    public void a(){}
    public void b(){}
    public void c(){}
}
​
public class Animal{
    public void breath(){
        System.out.println("会呼吸");
    }
}
​
public static void main(String[] args){
    Cat cat = new Cat();
    cat.eatFish();
    cat.sleep();
    cat.breath();
    
    CatKinds ck = new CatKinds();
    ck.sleep();
    ck.breath();
    
    Animal an = new Animal();
    an.breath();
    
    //上述案例得到的结果：子类可以调用父类的方法，但是父类不允许调用子类的方法的
    Cat cat1 = new Cat();
    cat.sleep();
    
    Tiger tiger = new Tiger();
    tiger.sleep();
    
    //示例：假设有个动物园，里面都是动物，朋友来参观，作为馆长给介绍下，发现动物们都在睡觉，描述方式有：
    //1、猫在睡觉，老虎在睡觉，豹子在睡觉,...
    //2、猫科动物们在睡觉-----该方式更简洁
    //为什么能够选择第二种方式来进行描述呢？因为猫科动物是它们的统称(父类)
}

语法：父类数据类型 变量名 = new 子类数据类型();

public static void main(String[] args){
    //向上转型，该变量就只能调用父类中也有的方法，而不能去调用子类中特有的方法
    CatKinds ck = new Cat();
    ck.sleep();
    //ck.eatfish();
    
    /*Cat cat = new Cat();
    cat.sleep();
    cat.a();
    cat.b();
    cat.c();
    Tiger tiger = new Tiger();
    tiger.sleep();
    tiger.a();
    tiger.b();
    tiger.c();*/
    Cat cat = new Cat();
    show(cat);
    Tiger tiger = new Tiger();
    show(tiger);
    byte b = 1;
    baseShow(b);//int a = 1
    animalShow(cat);
}
//猫科动物在睡觉--下述案例纯粹只是为了掩饰知识点
public static void show(CatKinds ck){//CatKinds ck = new Cat(); CatKinds ck=new Tiger();
    ck.sleep();
    ck.a();
    ck.b();
    ck.c();
    //如果在调用了公共的方法后需要去调用子类特有的方法，怎么办---强制类型转换
    //需要使用instanceof 判断引用数据类型
    if(ck instanceof Cat){
        Cat cat = (Cat)ck;
        cat.eatFish();
    }else if(ck instanceof Tiger){
        Tiger tiger = (Tiger)ck;
        tiger.king();
    }
}
public static void animalShow(Animal animal){//Animal animal = new Cat();
    animal.breath();
}
​
public static void baseShow(int a){
    byte c = (byte)a;
}
​
public static void show(Cat cat){
    cat.sleep();
    cat.a();
    cat.b();
    cat.c();
}
public static void show(Tiger tiger){
    tiger.sleep();
    tiger.a();
    tiger.b();
    tiger.c();
}

Object obj = new Cat();
//问题1：obj.eatFish();是否有问题，为什么？
//问题2：System.out.println(obj.toString()); 是否有问题，为什么？

总结：

向上转型：目的是为了限制对子类中特有方法的调用

向下转型：目的是为了调用子类中特有的方法

作业：多态练习题

思考：在多态的情况下，子类和父类中的变量有什么区别？

思考：在多态的情况下，子类和父类中的静态方法有什么区别？

思考：在多态的情况下，子类和父类中的非静态方法有什么区别？

 

参考链接：https://www.runoob.com/java/java-polymorphism.html（多态)