【Java基础】多态、equals、造型cast、访问修饰符（public、protected、default、private）、static、final

1、面型对象–多态

多态的概念：多态性就是指同样的消息被类的不同的对象接收时导致的完全不同的行为的一种现象。这里的消息即对类成员函数的调用。
实现上面调用宠物叫，每种宠物有各自的叫声

public class Pet {

    public void shout(){
        System.out.println("宠物在叫");
    }

    public static void main(String[] args) {
    //下面是一种新建对象方法
        Pet pets[] = new Pet[3];
        pets[0] = new Dog();
        pets[1] = new Cat();
        pets[2] = new Mouse();
        //第二种创建对象方法
        //Pet[] pets = new Pet[]{new Dog(),new Cat(),new Mouse()}
        for (Pet i:pets){
            i.shout();
        }
    }
}

public class Dog extends Pet {
    public void play(){
        System.out.println("玩");
    }
    public void run(){
        System.out.println("跑");
    }
    public void sleep(){
        System.out.println("睡");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void shout(){
        System.out.println("汪汪");
    }
}

public class Cat extends Pet {
    public void shout(){
        System.out.println("喵喵喵");

    }
}

public class Mouse extends Pet {
    public void shout(){
        System.out.println("吱吱吱");
    }
}

2、==和equals

2.1 equals方法

比较对象的虚地址，但是可以在类中被重写

String str  = new String("123");
        String str1 = new String("123");
        System.out.println(str.equals(str1));
       //返回值为ture
       

2.2 “==”

比较的是内存中的虚地址

  String str  = new String("123");
        String str1 = new String("123");
        System.out.println(str == str1);
        //返回值为false

2.3 重载equals

目的：实现自定义类的实例对象比较

package day6.testMath.testEquals;

public class Rect {
    private int x;
    private int y;
    private int width;
    private int height;
//  equals比较对象的虚地址（对象不同值相同返回true），
//  ==比较的是内存中的虚地址（对象不同返回false）。

    public Rect(int x,int y,int width,int height){
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;

    }


    public boolean equals(Object obj) {
    //instanceof是保留关键字，判断左边对象是否是右边的实例
        if(obj instanceof Rect){
            Rect r1 = (Rect)obj;
            if(r1.height==this.height&&r1.width==this.width){
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args){
        Rect rect1 = new Rect(1,2,4,5);
        Rect rect2 = new Rect(3,4,4,5);
        System.out.println(rect1.equals(rect2));        
    }
}

3、对象的造型casting

3.1 造型是什么

对象类型的转换，（跟基本数据类型的转换类似，也分为自动转换类型和强制转换类型）

3.2 向上转换

父类引用类型来指向子类对象，是自动完成的安全的，就像Pat pet = new Dog()

3.3向下转换

子类引用指向父类对象是不安全的需要强制转化。

Cat c = new Cat();
((Pet)c).sha();

4、封装的控制：访问修饰符

对象中属性和方法的可见度

例子

package day6.testMath.testFangwenxiushifu;

/**
 * @Auther:zyy
 * @Date:2022/8/19
 * @Description:day6.testMath.testFangwenxiushifu
 * @Version:1.0
 */
public class Box {
    private int length;
    private int width;
    private int height;
    public Box(int length,int width,int height){
        this.length = length;
        this.width = width;
        this.height = height;
    }
    private int areaA(){
        return length*width;
    }
    private int areaB(){
        return length*height;
    }
    private int areaC(){
        return width*height;
    }
    public int area(){
        return (areaA()+areaB()+areaC())*2;
    }
    public int volu(){
        return length*height*width;
    }
}

类的访问修饰符：
public：任何包中的类都可以访问该类
默认值：同一个包中的类可以访问该类

5、static和final关键字

5.1 关键字static

使用的地方：
静态属性、静态方法、静态初始化块、静态内部类

5.1.1 静态属性、方法

使用的地方	特点
静态属性及静态方法	static标记的属性或方法由整个类（所有实例）共享，如访问控制权限允许，可不必创建该类对象而直接用类名加“.”调用，比如我们通常可以使用静态属性、方法，来实现实例对象计数

5.1.2 静态初始化

在类的定义体中、方法的外部可被包含static语句块
static语句块仅在其所属的类被载入时执行一次
static块通常用于初始化staic（类）属性。

class Person{
    public static int total;
    static{
        total = 100;//为total赋初值
    }
 }

5.1.3 静态内部类

在类的内部，可以定义静态内部类

public class Cat extends Pet {
    private static String namePrefix = "猫咪";
    private String name;
    public static class CatManager{
        public static void showCat(){
            //静态内部类可以访问外部类的静态成员
            System.out.println(namePrefix);
            //静态内部类不能访问外部类的非静态成员
            //System.out.println(name); //报红
        }
    }
 }

5.2 关键字final

java中，final关键字可以给属性（变量）、方法、及类使用

属性	局部变量	方法	类

变量
final标记变量（成员变量或局部变量）即成为常量，只能赋值一次。
final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用
方法
final标记的方法，其不可被子类覆盖
类
final标价的类，不可被继承

5.3总结

修饰符	修饰对象	规则
static	属性	类或类的实例来调用，最好用类引用
	方法	只能调用静态变量或静态方法，不能使用this，super
	代码块	程序一加载静态代码块就运行，而且只运行一次
	静态内部类	在内部定义静态内部类，即内部类前面加上staic
final	属性	常量，final int I =12；或者 final int I；I=12
	方法	该方法不能被子类重写
	类	该类不能被继承，该类中的所有方法和属性都是fianl

例子
设计一个TeachCenter技工中心类， 其作用是培养技工Worker
Worker的功能为工作。其属性为:姓名、年龄、技能和工作单位。( 需考虑哪些属性应当在哪里确定)TeachCenter的功能为培养技工，每培养一-个技工就会在内部进行统计数量。在其中可以培养3种技能:计算机、建筑、冶炼。

按照自己的理解对整个实统进行设计，要求至少产生、培养5个技工。提示，对于属性请设定getter和setter。

在5.1static静态属性及方法一节的课堂练习题基础上。进一步完善TeachCenter类和Worker类的功能。
将Worker设定为不可继承的类。其姓名在初始化后不可更改。
将TeachCenter更改为:只有一个唯- -实例的对象(使用静态初始化)，其也不能被继承。内部管理的Worker数量不能是静态的。因此，相应的方法也需要修改为非静态的。

package day6.testMath.testStatic;

import com.sun.corba.se.spi.orbutil.threadpool.Work;

public class TeachCenter {
    private static String name;
    private  Worker[] work;
    private  int workNumber;
    private static int count=0;

    static{
        name = "中共教育";
    }
    public TeachCenter(Worker[] work){

        this.work =work;
       // count++;

    }

    public void setWork(Worker[] work) {
        this.work = work;
    }

    public Worker getWork() {
        return work[workNumber];
    }

    public void setWorkNumber(int workNumber) {
        this.workNumber = workNumber;
    }

    public int getWorkNumber() {
        return workNumber;
    }

    public static String getName() {
        return name;
    }
    //计数
    public static void showCenterCounts(){
        System.out.println("there are "+ TeachCenter.count +" worker");
    }
    public void trainComputer(Worker worker){
        worker.setSkill("计算机");
        count++;
    }
    public void trainArch(Worker worker){
        worker.setSkill("建筑");
        count++;
    }
    public void trainSmelt(Worker worker){
        worker.setSkill("冶炼");
        count++;
    }
    public void myPrint(){
        System.out.println("我的学员有：");
        for (int i=0;i<work.length;i++){
            System.out.print(work[i].getName()+"、");
        }
        System.out.println();
    }

    public static void main(String[] args) {

        Worker w1 = new Worker("一哥",20);
        Worker w2 = new Worker("二丫",15);
        Worker w3 = new Worker("三水",35);
        Worker[] work = new Worker[]{w1,w2,w3};
        TeachCenter tc1 = new TeachCenter(work);

        tc1.trainArch(work[0]);
        tc1.trainComputer(work[1]);
        tc1.trainSmelt(work[2]);
        //System.out.println(w1.getSkill());
        for(int i=0;i<work.length;i++){
            work[i].myPrint();
        }
        tc1.myPrint();

//
        TeachCenter.showCenterCounts();

    }

}

package day6.testMath.testStatic;


public final class  Worker {
    private final String name;
    private int age;
    private String skill;
    private String workplace;

    public Worker(String name,int age){
        this.name = name;
        this.age = age;

    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getSkill() {
        return skill;
    }

    public String getWorkplace() {
        return TeachCenter.getName();
    }

    public void setAge(int age) {
        this.age = age;
    }


    public void setSkill(String skill) {
        this.skill = skill;
    }

    public void setWorkplace(String workplace) {
        this.workplace = TeachCenter.getName();
    }

    public void myPrint(){
        System.out.println("姓名："+name+",年龄："+age+",技能："+skill+",工作的地方："+workplace);
    }


}