3.31 权限修饰符、重写、多态、转型、Object、抽象、toString

3.31 权限修饰符、重写、多态、转型、Object、抽象、toString

权限修饰符

​ 被不同权限修饰符修饰的内容能够被使用的范围

		本类	同包类	不同包的子类	不同包的其他类
	private	✔
	default	✔	✔
	protected	✔	✔	✔
	public	✔	✔	✔	✔

注意：

1）使用最多的private，public

2）这四个修饰符都是成员修饰符，只修饰成员，不能修饰局部

3）在不同包的子类下，若想使用父类中被protected修饰的成员，需要通过继承关系使用，不能通过父类对象使用

重写Override

重写与重载的区别：

重载：1.同一个类的多个方法 2.方法名相同 3.参数列表不同

重写：1.类需要时不同的两个类 2.这两个类需要有继承关系 3.方法签名相同

应用场景：在子类继承父类后，继承了一些功能方法，但对于有些方法的功能不满意，可以进行功能的重写

使用：1.子类方法一旦重写，子类对象调用的时候，会采用就近原则

​ 2.子类对象调用功能的时候，子类存在找子类，子类没有才会找父类

注意：1.子类一旦重写父类的方法，就是对父类方法进行屏蔽

​ 2.可以使用@Override 强制检查该方法是否符合重写规则

​ 3.被private、final、static修饰的方法不能被重写

一个重写的方法要求满足"=="、"<="、">=":

==: 方法签名需要完全相同

<=:返回值若是基本数据类型，则要求数据类型完全相同，若为引用数据类型则要求子类的引用数据类型<=父类的引用数据类型

“>=”:子类方法的权限修饰符>=父类犯法的权限修饰符

多态

​ 多态：一种事物的多种形态

​ 多态的最终体现：父类的引用指向子类的对象

​ 多态的前提：继承|执行

​ 多态的优点：多态可以让程序变得更加灵活，便于后期的维护

​ 当通过父类的引用调用成员方法的时候，如果子类有重写方法就调用重写，如果子类没有重写方法就找父类，如果多态 方法的重写，多态也就没有意义

class Person{}
class Student extends Person{}

Student s = new Student();
//等号左边代表你的外表，等号右边代表你的内在（数据）
Person p = new Student();
//一个学生的内在，外壳是一个人--->多态

Cast 转型

​ 转型:引用类型的类型提升

​ 向上转型 ≈ 自动类型提升—>从小到大—>从子类到父类

​ 向下转型 ≈ 强制类型转换—>从大到小—>从父类到子类—>小范围类型变量 = (小范围类型) 大范围类型的数据

​ 向下转型时可能遇到类型转换异常 ClassCastException，这时需要引用 instanceof 类型 判断前面的引用是否指向后面类 型的对象，或者是否指向后面类型子类的对象，如果是返回true，不是返回false

​ 注意：多态引用不能调用子类中独有的方法，对子类的新增功能不可见，如果要调用子类独有的方法，需要向下转型

Java Object

​ Object类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。

​ Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动 继承 Object，成为 Object 的子类。

​ Object 类可以显示继承，也可以隐式继承

abstract

​ 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个 类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

​ 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

​ 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设 计抽象类。

​ 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

​ 在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

toString

​ 当打印一个对象的引用时，默认会调用toString，打印的时当前对象调用了toString之后的返回值

代码

package homework.circledemo;
/*
1.编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）
提示:（1）编写一个圆类Circle，该类拥有：
1)	一个成员变量，radius（私有，浮点型）;//存放圆的半径；
2)	两个构造方法
Circle（）              //将半径设为0
Circle（double  r ）    //创建Circle对象时将半径初始化为r
3)	三个成员方法
double getArea（）      //获取圆的面积
double getPerimeter（）  //获取圆的周长
void show（）           //将圆的关径、周长、面积输出到屏幕
		（2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：
1)	一个成员变量，double hight  （私有，浮点型）;  //圆柱体的高；
2)	构造方法
//创建Cylinder对象时将半径初始化为r,高度初始化为h
Cylinder（double r,double h）
3)	成员方法
double getVolume（）            //获取圆柱体的体积
void showVolume（）             //将圆柱体的体积输出到屏幕

 */

public class CircleDemo {
    public static void main(String[] args) {
        Circle circle = new Circle();
        Circle circle1 = new Circle(3.0);
        circle1.show();

        Cylinder cylinder = new Cylinder(2.0,2.0);
        System.out.println("圆柱底面半径为："+cylinder.getRadius());
        System.out.println("圆柱高为："+cylinder.getHight());
        System.out.println("圆柱体积为"+cylinder.getVolume());
    }
}

class Circle{
    //半径
    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }


    //构造方法
    public Circle(){
        System.out.println("将半径设为0");
    }
    public Circle(double r){
        this.radius = r;
    }
    //方法
    //面积
    double getArea(double r){
        double area = Math.PI*(r*r);
        return area;
    }
    //周长
    double getPerimeter(double r){
        double perimeter = 2*r*Math.PI;
        return perimeter;
    }
    //将圆的关径、周长、面积输出到屏幕
    void show(){
        System.out.println("该圆的半径为:"+this.radius);
        System.out.println("该圆的为周长:"+this.getPerimeter(this.radius));
        System.out.println("该圆的为面积:"+this.getArea(this.radius));

    }
}

class Cylinder extends Circle{
    public double getHight() {
        return hight;
    }

    public void setHight(double hight) {
        this.hight = hight;
    }

    //高
    private double hight;
    //构造方法
    public Cylinder(double r,double h){
        this.hight = h;
        this.setRadius(r);
    }
    //成员方法
    double getVolume(){
        double volume = Math.PI*this.hight*this.getArea(this.getRadius());
        return volume;
    }
    void showVolume(){
        System.out.println(this.getVolume());
    }
}

package homework.car;
/*
2.	请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。
设定
1)	出租车类:
属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2)	家用轿车类：
属性包括：车型，车牌，车主姓名；方法包括：启动，停止
要求
1)	分析出租车和家用轿车的公共成员，提取出父类—汽车类
2)	利用继承机制，实现出租车类和家用轿车类
3)	编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法
4)	定义名为car的包存放汽车类，出租车类，家用轿车类和测试类
运行效果

 */
public class TaxiAndSedan {
    public static void main(String[] args) {

    }
}
class Car{
    //变量
    public String type;
    public String  num;
    //构造器
    public Car(){}
    //构造器
    public Car(String type,String num){
        this.type = type;
        this.num = num;
    }
    void start(){
        System.out.println("我是车，我启动");
    }
    void stop(){
        System.out.println("我是车，我停下");
        System.out.println("======================");
    }
}
class Taxi extends Car{
    //出租车公司名字
    public String company;
    //构造器
    public Taxi(String company,String num){
        this.company = company;
        super.num = num;
        super.type = type;
    }
    @Override void start(){
        System.out.println("乘客您好");
        System.out.println("我是"+this.company+"出租车公司的，我的车牌是"+this.num+"，您要去哪里？");
    }
    @Override void stop(){
        System.out.println("目的地已经到了，请您付费下车，欢迎再次乘坐");
        System.out.println("======================");
    }
}
class Sedan extends Car{
    //车主姓名
    public String name;
    //构造器
    public Sedan(String name){
        this.name = name;
    }
    //方法的重写
    @Override void start(){
        System.out.println("我是"+this.name+"我的汽车我做主");
    }
    @Override void stop(){
        System.out.println("目的地到了，我们去玩吧");
        System.out.println("======================");
    }
}
package homework.car;

public class Test {
    public static void main(String[] args) {
        //汽车测试
        Car car = new Car();
        car.start();
        car.stop();
        //家用轿车测试
        Car sedan = new Sedan("武大郎");
        sedan.start();
        sedan.stop();
        //出租车测试
        Car taxi = new Taxi("景顺","京B123");
        taxi.start();
        taxi.stop();
    }
}


package homework.mon;

public class NewGame {
}

class Monster{
    public String name;
    public int hp;
    public int atk;

    void attack(){
        System.out.println(this.name+"展开攻击");
    }
    void move(){}
    void show(){
        System.out.println(this.name+"展开攻击");
        System.out.println("当前生命值是："+this.hp);
        System.out.println("攻击力是："+this.atk);
    }
}

class Snake extends Monster{
    //构造器
    public Snake(String name,int hp,int atk){
        super.hp = hp;
        super.name = name;
        super.atk = atk;
    }
    //方法
    @Override void move(){
        System.out.println("我是蛇怪，我走S型路线");
    }
    int recover(){
        if(this.hp<10){
            this.hp+=20;
        }
        return this.hp;
    }
}

class Centipede extends Monster{
    //构造器
    public Centipede(String name,int hp,int atk){
        super.hp = hp;
        super.name = name;
        super.atk = atk;
    }
    //方法
    @Override void move(){
        System.out.println("我是蜈蚣精，御风飞行");
    }
}

package homework.mon;

import javax.swing.*;

public class Test {
    public static void main(String[] args) {
        Snake snake = new Snake("怪物蛇甲妖",5,20);
        snake.show();
        System.out.println("实施大蛇补血术。。。。。，当前生命值是："+snake.recover());
        snake.move();
        System.out.println("=====================");

        Centipede centipede = new Centipede("怪物蜈蚣",60,15);
        centipede.show();
        centipede.move();
    }
}