第八章基本类型包装类和多态

1.练习回顾

父类(Car):

public class Car {
    protected String name;
    protected String color;

    public Car(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public void run(){
        System.out.println("汽车跑");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

子类(Bus)：

public class Bus extends Car{
    //最大载客量
    private int maxNum;
    //alt+insert 生成代码:构造方法，getter,setter,方法重写，toString
    //alt+enter  修复错误
    public Bus(String name, String color,int maxNum) {
        //调用父类构造,满足先有父再有子的原则
        super(name, color);
        this.maxNum=maxNum;
    }


    //@Override:在编译的时候,系统帮你检查对应方法是否实现了重写
    @Override
    public void run() {
        System.out.println(this.color+"的,载客量"+this.maxNum+"的"+this.name+"开往下一站");
    }

    public int getMaxNum() {
        return maxNum;
    }

    public void setMaxNum(int maxNum) {
        this.maxNum = maxNum;
    }
}

子类(Taxi)：

public class Taxi extends Car{
    //所属公司
    private String company;

    public Taxi(String name, String color,String company) {
        super(name, color);
        this.company=company;
    }

    @Override
    public void run() {
        System.out.println(this.color+"的"+this.company+this.name+"将客人拉往目的地");
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }
}

测试类:

public class Test {
    public static void main(String[] args) {
        Bus bus = new Bus("公交车","白色",25);
        bus.run();
        Taxi taxi = new Taxi("出租车","绿色","大众");
        taxi.run();
    }
}

2.基本类型(四类八种)包装类 2.1 概念

基本数据类型使用非常方便,但是我们没有对应的方法去操作他们，可以通过一个类把基本数据类型包装起来，在类中定义一些方法，这个类就叫做包装类，我们可以使用包装类中定义的方法去操作基本数据。

基本数据类型和对应的包装类:

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

2.2 自动装箱与自动拆箱

分别对应：

基本数据类型转换成包装类；包装类转换成基本数据类型。

2.3 基本数据类型与字符串之间的转换 2.3.1 基本类型(数字)——>字符串(String)

①可以使用数字+空字符串；

String a = 5 + "";

②使用integer包装类的方法 toString(int i);

String a = Integer.toString(100);

③使用String类的方法 valueOf(int i);

String a  = String.valueOf(100);

2.3.1 字符串(String)——> 基本数据类型(数字)

注：只有数字类型的字符串，才可以转换成数字

使用包装类的方法 xxx.parseXXX("数字类型的字符串");

int b = Integer.parseInt(a);

double c = Double.parseDouble("5.22");

2.4 Integer的缓存

先看代码及运行结果:

        Integer a = 100;
        //'Integer(int)' is deprecated 已弃用
        Integer b = new Integer(100);
        System.out.println(a==b);
        Integer c = 200;
        Integer d = 200;
        System.out.println(c==d);
        System.out.println(c.equals(d));

产生这种结果的原因：

①"==" 比较的是数据的地址，".equals()"比较的是内容;

②Integer 对数值处理做了优化，在给Integer对象赋值的过程实际上是调用了 public static Integer valueOf(int i) 这个方法，此方法将始终缓存128到127（包括128，127）范围内的值，并且获取的都是同一个数据，如果超出这个范围才会创建一个新的整形对象。

3. toString()方法和final关键字 3.1 toString() 任何类都是Object类的直接子类或者间接子类,在Object类中有一个toString()方法，当输出一个对象时，先调用当前类的toString()方法，如果当前类没有toString() ，就去找当前类的父类，看是否有toString()方法,如果过父类也没有，就去找 Object类中的toString()方法并运行。 Object类中的toString()方法：

很明显这个方法并不能达到目的，所以为了我们能够在使用的过程中方便调试查看对象，我们需要对 toString()方法进行重写。

idea中两个快捷键组合：

Ctrl+鼠标左键：点击方法名可自动跳转，查看该方法内容；

Alt+Insert：可以自动生成相关的构造方法、getter和setter方法、toString方法等等。

3.2 final 关键字

它表示最终的，不可改变的。

三种用法：
① 可以用来修饰类：final修饰的类不能被继承，也就意味着这个类其中的方法不能被重写； ② 可以用来修饰方法：final关键字修饰的方法不能被覆盖、重写，表示一个最终的方法； ③ 可以用来修饰变量：final修饰成员变量——>常量(命名必须全大写、一般多个单词使用下划线连接) D_AGE，CAT_AGE， PI等。

基本数据类型：使用final修饰的基本数据类型值不能变，并且只能被赋值一次。

引用数据类型：使用final修饰的引用类型，引用的地址值不能改变，但是对象的属性值可以改变。
① 对于成员变量来说，使用final修饰照样是不可变的，但是因为成员变量有默认值，所以必须手动赋值； ② 对final修饰的成员变量来说，可以直接赋值，也可以通过构造方法赋值，但是必须二选一； ③ 如果要通过构造方法赋值，并且类中有多个构造方法，必须保证每一个构造方法都要对 final修饰的成员变量赋值。

public class Test {
    public static void main(String[] args) {
        Bus bus = new Bus();
        System.out.println(bus.num);

        //常量:1.必须赋值 2.赋值之后不能再改变
        //    1.全局常量 2.局部常量 3.静态常量
        //    1.可以修饰类，则类不能被继承
        //    2.修饰方法，则方法不能被重写
        //    3.修改变量，则变量不能被重新复制

        final Student s = new Student();
        //s中的属性并没有被final修饰，所以可以改变
        s.name="xxx";
        s.age=20;
//
        s.name="bbb";
        s.age=23;

        //final s不能指向新对象
        //s = new Student();
    }
}

4.多态 4.1 什么是多态

多态的前提是继承和方法重写。

对于父类中的一个方法，在不同子类中有不同的实现，父类引用子类对象，调用父类被重写的方法时，子类有不同的响应。这就是多态。

4.2 为什么使用多态

实现程序设计的开-闭原则,对扩展开放，对修改关闭。

4.3 如何实现多态

①继承:子类继承父类； ②重写:子类方法重写父类方法； ③向上转型:父类引用指向子类对象； ④调用父类被重写的方法时，不同的子类效果不同。

演示：

①宠物Pet:

public class Pet {
    String name;
    String color;

    public Pet(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public void eat(){

    }
}

②Cat：

public class Cat extends Pet{

    public Cat(String name, String color) {
        super(name, color);
    }

    @Override
    public void eat() {
        System.out.println(this.color+"的"+this.name+"正在吃大餐!");
    }
}

③Dog：

public class Dog extends Pet{

    public Dog(String name, String color) {
        super(name, color);
    }

    @Override
    public void eat() {
        System.out.println(this.color+"的"+this.name+"在吃...");
    }
}

④Test：

public class Test {
    public static void main(String[] args) {
        Pet p1 = new Dog("小狗","黄色");
        Pet p2 = new Cat("小猫","白色");
        p1.eat();
        p2.eat();
    }
}

第八章 基本类型包装类和多态

Java相关栏目本月热门文章

第八章基本类型包装类和多态