OOP2

标签：String 子类 System OOP2 父类 public out

一、面向对象特征之二：继承性
1、继承的示例
为描述和处理个人信息，定义类Person:

public class Person {
    public String name;
    public int age;
    public Date birthDate;
    public String getInfo() {
        //...
    }
}

为描述和处理学生信息，定义类Student:

public class Student {
    public String name;
    public int age;
    public Date birthDate;
    public String school;
    public String getInfo() {
        // ...
    }
}

通过继承，简化Student类的定义:

public class Person {
    public String name;
    public int age;
    public Date birthDate;
    public String getInfo() {
        // ...
    }
}

public class Student extends Person {
    public String school;
}

2、为什么要有继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”

3、类继承语法规则

class Subclass extends SuperClass{ }

4、作用

5、注意点

子类继承了父类，就继承了父类的方法和属性。

在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

6、关于继承的规则

子类不能直接访问父类中私有的(private)的成员变量和方法。

7、单继承和多层继承

（1）Java只支持单继承和多层继承，不允许多重继承

一个子类只能有一个父类
一个父类可以派生出多个子类

class SubDemo extends Demo{ } //ok
 
class SubDemo extends Demo1,Demo2...//erro

（2）单继承与多层继承举例

8、代码示例

/**
 * @description: 生物类
 */
public class Creature {
    public void breath(){
        System.out.println("呼吸...");
    }
}

/**
 * @description:
 */
public class Person extends Creature{
     private String name;
     int age;
 
    public Person() {
    }
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void eat(){
        System.out.println(name + "吃饭...");
    }
 
    public void sleep(){
        System.out.println(name + "睡觉");
    }
}

/**
 * @description:
 */
public class Student extends Person{
//     private String name;
//     int age;
     String major; //专业
 
    public Student() {
    }
 
    public Student(String name, int age, String major) {
        setName(name);
        this.age = age;
        this.major = major;
    }
 
//    public void eat(){
//        System.out.println(name + "吃饭...");
//    }
//
//    public void sleep(){
//        System.out.println(name + "睡觉");
//    }
 
    public void study(){
        System.out.println(getName() + "学习...");
    }
}

/**
 * @description:
 *
 * 面向对象的特征之二：继承性
 *
 * 一、继承的好处 why?
 * （1）减少了代码的冗余，提高了代码的复用性
 * （2）便于功能的扩展
 * （3）为之后的多态性提供了前提
 *
 * 二、继承性的格式：class A extends B{}
 *  A：子类、派生类、subclass
 *  B：父类、超类、superclass
 *
 *  2.1 体现：一旦子类A继承了父类B以后，子类A就获取了父类B中声明的结构：属性和方法
 *  特别的：父类声明为private的属性和方法，子类继承父类之后，仍然认为获取了父类中的私有结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。
 *
 *  2.2 子类继承父类之后，还可以声明自己特有的属性或方法，实现功能的拓展。
 *  子类和父类的关系，不同于子集和集合的关系
 *  extends：延展、扩展
 *
 *  三、Java中关于继承性的规定
 *  （1）一个类可以被多个子类继承
 *  （2）Java中类的单继承性：一个类只能有一个父类
 *  （3）子父类是相对的概念
 *  （4）子类直接继承的父类，称为直接父类。间接继承的父类，间接父类。
 *  （5）子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
 *
 *  四、1、如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
 *      2、所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
 *      3、意味着，所有的java类都具有java.lang.Object类声明的功能
 *
 */
public class ExtendTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.age = 28;
        person.eat();
 
        Student student = new Student();
        student.setName("李四");
        student.age = 30;
        student.major = "计算机";
        student.eat();
        student.study();
        student.breath(); //间接父类中的方法
 
        Creature creature = new Creature();
 
    }
}

二、方法的重写(override/overwrite)
1、定义
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
2、要求

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
- 子类不能重写父类中声明为private权限的方法
子类方法抛出的异常不能大于父类被重写方法的异常
3、注意
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类方法覆盖父类的方法。

4、重写方法举例

public class Person {
    private String name;
    private int age;
 
    public Person() {
    }
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public void eat(){
        System.out.println("吃饭");
    }
 
    public void walk(int distance){
        System.out.println("行走了" + distance + "km");
    }
}

public class Student extends Person{
    private String major;
 
    public Student() {
    }
 
    public Student(String major) {
        this.major = major;
    }
 
   public void study(){
       System.out.println("学习，专业是: " + major);
   }
 
   //重写了父类的eat()
    public void eat() { //Overrides method in Person
        System.out.println("学生要多吃有营养的食物");
    }
}

/**
 * 方法的重写（override / overwrite）
 * 1、重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
 * 2、应用：重写以后，当创建子类对象以后，通过子类对象调用字父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
 * 3、重写的规定：
 *      方法的声明：权限修饰符 返回值类型  方法名(形参列表) throws 异常的类型 {方法体}
 *      约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
 *      （1）子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同。
 *      （2）子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
 *          特殊情况：子类不能重写父类中声明为private权限的方法
 *      （3）返回值类型
 *          父类被重写的方法返回值类型是void，则子类重写的方法的返回值类型只能是void
 *          父类被重写的方法返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或者A类的子类型
 *          父类被重写的方法返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型
 *      （4）子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
 *
 *      子类和父类中同名同参数的方法，要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）
 *
 *
 * 面试题：区分方法的重载与重写
 */
public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student("计算机技术");
        student.setName("张三");
        student.setAge(18);
        student.walk(10);
        student.study();
        student.eat();
    }
}

子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

举反例来进行说明，咱们就让子类重写的方法的权限的修饰符小于父类对应方法的修饰权限分析一下会怎么样。

class A{

public void m(){}

}

class B extends A{

private void m(){}

}

A a=new B(); // a对象的声明是A类，所以a对象能干什么要看A类，A类告诉a对象有一个m方法可以使用，而且m方法可以再任何地方使用

a.m(): //a对象本质上是B类来创建的，所以m方法分执行要看B类，B类告诉a对象m方法只能在本类中使用------产生冲突

三、四种访问权限修饰符
Java权限修饰符public、protected、 (缺省)、 private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于class的权限修饰只可以用public和default(缺省)。

public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。

1、访问控制举例

package com.notes;
 
public class Order {
    private int orderPrivate;
    int orderDefault;
    protected int orderProtected;
    public int orderPublic;
 
    public Order() {
    }
 
    public Order(int orderPrivate, int orderDefault, int orderProtected, int orderPublic) {
        this.orderPrivate = orderPrivate;
        this.orderDefault = orderDefault;
        this.orderProtected = orderProtected;
        this.orderPublic = orderPublic;
    }
 
    private void orderPrivate(){
        System.out.println("orderPrivate: " + orderPrivate);
    }
 
    void orderDefault(){
        System.out.println("orderDefault: " + orderDefault);
    }
 
    protected void orderProtected(){
        System.out.println("orderProtected: " + orderProtected);
    }
 
    public void orderPublic(){
        System.out.println("orderPublic: " + orderPublic);
    }
}

package com.notes;

public class OrderTest {
    //同一个包中其它的类，不可以调用Order类中私有的属性和方法
    public static void main(String[] args) {
        Order order = new Order();
//        order.orderPrivate = 1; //'orderPrivate' has private access
        order.orderDefault = 2;
        order.orderProtected = 3;
        order.orderPublic = 4;
 
//        order.orderPrivate(); //'orderPrivate()' has private access
        order.orderDefault();
        order.orderProtected();
        order.orderPublic();
    }
}

package com.notes.other;
 
import com.notes.Order;
 
public class OrderTest {
    ///不同包的普通类（非子类）中，不能调用Order类中声明为private、缺省和protected权限的属性、方法
    public static void main(String[] args) {
        Order order = new Order();
        //        order.orderPrivate = 1; //'orderPrivate' has private access
//        order.orderDefault = 2; //'orderDefault' is not public
//        order.orderProtected = 3; //'orderProtected' has protected
        order.orderPublic = 4;
 
//        order.orderPrivate(); //'orderPrivate()' has private access
//        order.orderDefault(); //'orderDefault()' is not public
//        order.orderProtected(); //'orderProtected()' has protected
        order.orderPublic();
    }
}

package com.notes.other;
 
import com.notes.Order;
 
public class SubOrder extends Order {
    //不同包的子类中，不能调用Order类中声明为private和缺省权限的属性、方法
    public void method(){
//        orderPrivate = 1; //'orderPrivate' has private access
//        orderDefault = 2; //'orderDefault' is not public
        orderProtected = 1;
        orderPublic = 2;
 
//        orderPrivate(); //'orderPrivate()' has private access
//        orderDefault(); //'orderDefault()' is not public
        orderProtected();
        orderPublic();
    }
}

2、访问控制分析

四、关键字：super

/**
 * super关键字的使用
 * 1、super理解为：父类的
 * 2、super可以用来调用属性、方法、构造器
 * 3、super的使用
 *  （1）我们可以在子类的方法或构造器中，通过使用 “super.属性” 或 “super.方法” 的方式，显示的调用父类中声明的属性或方法。
 *  但是通常情况下，我们习惯省略 “super”
 *  （2）特殊情况：当子类和父类中定义了同名的属性时，我们想要在子类中调用父类声明的属性，则必须显示的使用 “super.属性” 的方式，表明调用的是父类中声明的属性。
 *  （3）特殊情况：当子类重写了父类的方法以后，我们想要在子类中调用父类中被重写的方法时，必须显式的使用 “super.方法” 的方式，表明调用的是父类中被重写的方法。
 *
 *  4、super调用构造器
 *   （1）我们可以在子类的构造器中显式的使用 “super(形参列表)” 的方式，调用父类中声明的指定的构造器
 *   （2）“super(形参列表)” 的使用，必须声明在构造器的首行
 *   （3）我们在类的构造器器中，针对“this(形参列表)” 和 “super(形参列表)” 只能二选一
 *   （4）在构造器的首行，没有显式的声明 “this(形参列表)” 和 “super(形参列表)”，则默认调用的是父类中空参的构造器 “super()”
 *   （5）在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造器
 */
public class CylinderTest {
    public static void main(String[] args) {
//        Cylinder cylinder = new Cylinder();
        Cylinder cylinder = new Cylinder(1,2);
        double area = cylinder.findArea();
        System.out.println("圆柱的表面积: " + area);
        double volume = cylinder.findVolume();
        System.out.println("圆柱的体积: " + volume);
    }
}

/**
 * @description: 圆
 */
public class Circle {
    private double radius;
 
    public Circle() {
        System.out.println("Circle()");
        radius = 1;
    }
 
    public Circle(double radius) {
        System.out.println("Circle(double radius)");
        this.radius = radius;
    }
 
    public void setRadius(double radius){
        this.radius = radius;
    }
 
    public double getRadius() {
        return radius;
    }
 
    /**
     * 计算圆的面积
     * @return 返回圆的面积
     */
    public double findArea(){
        return Math.PI * Math.pow(radius, 2);
    }
}

/**
 * @description: 圆柱
 */
public class Cylinder extends Circle {
    private double length;
 
    public Cylinder() {
//        super(); //默认调用
        length = 1;
    }
 
    public Cylinder(double length) {
        this.length = length;
    }
 
    public Cylinder(double radius, double length) {
        super(radius);//super调用父类的构造器
        this.length = length;
    }
 
    public double getLength() {
        return length;
    }
 
    public void setLength(double length) {
        this.length = length;
    }
 
    /**
     * 计算圆柱的表面积
     * @return
     */
    public double findArea() {
//        return Math.PI * Math.pow(getRadius(), 2) * 2 + 2 * Math.PI * getRadius() * length;
        return super.findArea() * 2 + 2 * Math.PI * getRadius() * length; //super调用父类的方法
    }
 
    /**
     * 计算圆柱的体积
     * @return 返回圆柱的体积
     */
    public double findVolume(){
//        return Math.PI * Math.pow(getRadius(), 2) * length;
        return super.findArea() * length; ////super调用父类的方法
    }
}

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器
1、注意
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

super的追溯不仅限于直接父类
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

2、关键字super举例

五、子类对象实例化过程

/*
 * @author: huxingxin
 * @date: 2022/12/7 23:34:22
 * @description:
 *
 * 子类对象实例化的全过程
 * 1、从结果上来看（继承性）：
 *      子类继承父类以后，就获取了父类声明的属性和方法。
 *      创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
 * 2、从过程上来看：
 *      当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止
 *      正因为加载过所有的父类的结构，所以才可以看到内存中有父类的结构，子类对象才可以考虑进行调用
 *
 * 明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象
 */

思考：

1).为什么super(…)和this(…)调用语句不能同时在一个构造器中出现？

2).为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现？

class Creature {
    public Creature() {
        System.out.println("Creature无参数的构造器");
    }
}

class Animal extends Creature {
    public Animal(String name) {
        System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
    }
    public Animal(String name, int age) {
        this(name);
        System.out.println("Animal带两个参数的构造器，其age为" + age);
    }
}

public class Wolf extends Animal {
    public Wolf() {
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args) {
        new Wolf();
    }
}

Dog dog = new Dog("小花","小红");

this(…) 或 super(…) 或 super()

六、面向对象特征之三：多态性

/**
 * 面向对象特性之三：多态性
 *
 * 1、理解多态性：可以理解为一个事物的多种形态。
 *
 * 2、何为多态性：
 *      对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
 *
 * 3、多态的使用：虚拟方法调用
 *      有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
 *      总结：编译，看左边，运行，看右边
 *
 * 4、多态性的使用前提 （1）类的继承关系 （2）方法的重写
 *
 * 5、对象的多态性，只适用于方法，不适用于属性 （编译和运行都看左边）
 *
 */
public class PersonTest {
    public static void main(String[] args) {
        Person person = new Person("张三", 30);
        person.eat();
        person.walk();
 
        Man man = new Man();
        man.eat();
        man.walk();
        man.earnMoney();
 
        System.out.println();
        /**-------------------------------------------------------*/
        //对象的多态性：父类的引用指向子类的对象
        Person person1 = new Man();
        //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法-->虚拟方法调用
        person1.eat();
        person1.walk();
        //编译看左边 运行看右边
        // person1.earnMoney(); //Cannot resolve method 'earnMoney' in 'Person'
 
        //对象的多态性，只适用于方法，不适用于属性 （编译和运行都看左边）
        Person person2 = new Woman();
        int id = person2.id;
        System.out.println("id: " + id);
    }
}

public class Person {
    private String name;
    private int age;
    int id = 1001;
 
    public Person() {
    }
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
 
    public void eat(){
        System.out.println(name == null ? "人吃饭" : name + "吃饭");
    }
 
    public void walk(){
        System.out.println(name == null ? "人走路" : name + "走路");
    }
}

public class Man extends Person {
    private boolean isSmoking;
    int id = 1002;
 
    public Man() {
    }
 
    public Man(boolean isSmoking) {
        this.isSmoking = isSmoking;
    }
 
    public Man(String name, int age, boolean isSmoking) {
        super(name, age);
        this.isSmoking = isSmoking;
    }
 
    public boolean getIsSmoking() {
        return isSmoking;
    }
 
    public void setIsSmoking(boolean smoking) {
        isSmoking = smoking;
    }
 
    @Override
    public void eat() {
        System.out.println("男人多吃肉, 长肌肉");
    }
 
    @Override
    public void walk() {
        System.out.println("男人走路虎虎生威");
    }
 
    public void earnMoney(){
        System.out.println("男人负责挣钱养家");
    }
}

public class Woman extends Person{
    private boolean isBeauty;
    int id = 1003;
 
    public Woman() {
    }
 
    public Woman(boolean isBeauty) {
        this.isBeauty = isBeauty;
    }
 
    public Woman(String name, int age, boolean isBeauty) {
        super(name, age);
        this.isBeauty = isBeauty;
    }
 
    public boolean getIsBeauty() {
        return isBeauty;
    }
 
    public void setIsBeauty(boolean beauty) {
        isBeauty = beauty;
    }
 
 
    @Override
    public void eat() {
        System.out.println("女人少吃, 为了保持身材");
    }
 
    @Override
    public void walk() {
        System.out.println("女人走路婀娜多姿");
    }
 
 
    public void goShopping(){
        System.out.println("女人喜欢购物");
    }
}

1、多态性的体现

多态性，是面向对象中最重要的概念，在Java中的体现：

对象的多态性：父类的引用指向子类的对象

可以直接应用在抽象类和接口上

2、为什么出现多态性

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

**多态情况下 **

“看左边” ：看的是父类的引用（父类中不具备子类特有的方法）

“看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）

对象的多态 —在Java中,子类的对象可以替代父类的对象使用

一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student(); 
e.school = “pku”; //非法,Person类没有school成员变量

属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

3、多态性应用举例

public class Test {
    public void method(Person e) {
        // ……
        e.getInfo();
    }
    public static void main(Stirng args[]) {
        Test t = new Test();
        Student m = new Student();
        t.method(m); // 子类的对象m传送给父类类型的参数e
    }
}

正常的方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下)

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型

编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

虚拟方法调用举例：

前提：Person类中定义了welcome()方法，各个子类重写了welcome()。

执行：多态的情况下，调用对象的welcome()方法，实际执行的是子类重写的方法。

4、练习

public class CylinderTest {
    public static void main(String[] args) {
        Circle circle = new Circle(2);
        double area = circle.findArea();
        System.out.println("圆的面积: " + area);
 
        Cylinder cylinder = new Cylinder(2, 2);
        double area1 = cylinder.findArea();
        double volume = cylinder.findVolume();
        System.out.println("圆柱的表面积: " + area1);
        System.out.println("圆柱的表面积: " + volume);
    }
}

/**
public class Circle {
    private double radius;
 
    public Circle() {
        radius = 1;
    }
 
    public Circle(double radius) {
        this.radius = radius;
    }
 
    public double getRadius() {
        return radius;
    }
 
    public void setRadius(double radius) {
        this.radius = radius;
    }
 
    /**
     * 计算圆的面积
     * @return 返回计算圆的面积
     */
    public double findArea(){
        return Math.PI * Math.pow(radius, 2);
    }
}

public class Cylinder extends Circle{
    private double length;
 
    public Cylinder() {
        length = 1;
    }
 
    public Cylinder(double length) {
        this.length = length;
    }
 
    public Cylinder(double radius, double length) {
        super(radius);
        this.length = length;
    }
 
    public double getLength() {
        return length;
    }
 
    public void setLength(double length) {
        this.length = length;
    }
 
    /**
     * 计算圆柱的表面积
     * @return 返回圆柱的表面积
     */
    @Override
    public double findArea() {
        return super.findArea() * 2 + 2 * Math.PI * getRadius() * length;
    }
 
    /**
     * 计算圆柱的体积
     * @return 返回圆柱的体积
     */
    public double findVolume(){
        return super.findArea() * length;
    }
}

七、方法的重载与重写
1、二者的定义细节

/**
 * 方法的重载
 *  1、定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
 *     两同一不同：同一个类、相同方法名
 *                参数列表不同：参数个数不同、参数类型不同
 *
 *  2、举例：
 *      Arrays类中重载的方法 sort() binarySearch()
 *
 *  3、判断是否是重载
 *      跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
 *
 *  4、在通过对象调用方法时，如何确定某一个指定的方法
 *      方法名 --> 参数列表
 */

/**
 * 方法的重写（override / overwrite）
 * 1、重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
 * 2、应用：重写以后，当创建子类对象，通过子类对象调用字父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
 * 3、重写的规定：
 *      方法的声明：权限修饰符 返回值类型  方法名(形参列表) throws 异常的类型 {方法体}
 *      约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
 *      （1）子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同。
 *      （2）子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
 *          特殊情况：子类不能重写父类中声明为private权限的方法
 *      （3）返回值类型
 *          父类被重写的方法返回值类型是void，则子类重写的方法的返回值类型只能是void
 *          父类被重写的方法返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或者A类的子类型
 *          父类被重写的方法返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型
 *      （4）子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
 *
 *      子类和父类中同名同参数的方法，要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）
 *
 *
 */

2、从编译和运行的角度看
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。

所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

八、多态小结
1、多态作用
提高了代码的通用性，常称作接口重用
2、前提
需要存在继承或者实现关系
有方法的重写
3、成员方法
编译时：要查看引用变量所声明的类中是否有所调用的方法。
运行时：调用实际new的对象所属的类中的重写方法。
4、成员变量
不具备多态性，只看引用变量所声明的类

九、instanceof 操作符

public class PersonTest {
    public static void main(String[] args) {
        Person person2 = new Woman();
        //不能调用子类特有的方法、属性: 编译时，person2是Person类型
//        person2.setIsBeauty(true); //Cannot resolve method 'setIsBeauty' in 'Person'
//        person2.goShopping(); //Cannot resolve method 'goShopping' in 'Person'
 
        //有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，
        // 但是由于变量声明为父类类型，导致编译时，只能调用父类声明的属性和方法，子类特有的属性和方法不能调用
 
        //如何才能调用子类特有的属性和方法
        //向下转型：使用强制类型转换符
        Woman woman = (Woman) person2;
        woman.setIsBeauty(true);
        woman.goShopping();
 
        //使用强转时，可能出现 ClassCastException
//        Man person21 = (Man) person2; //Exception in thread "main" java.lang.ClassCastException
 
        //instanceof 关键字的使用
        // a instanceof A : 判断对象a是否是类A的实例。如果是，返回true，如果不是，返回false。
        //使用情景：为了避免在向下转型时出现 ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就向下转型，返回false，不进行向下转型
        //如果 a instanceof A 返回true，则 a instanceof A的父类也返回true
        if (person2 instanceof  Man){
            System.out.println("person2是Man的实例");
        }
        if (person2 instanceof Woman){
            System.out.println("person2是Woman的实例");
        }
    }
}

x instanceof A：检验x是否为类A的对象，返回值为boolean型

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

如果x属于类A的子类B，x instanceof A值也为true。

public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
-------------------------------------------------------------------
public void method1(Person e) {
if (e instanceof Person) 
// 处理Person类及其子类对象
if (e instanceof Student) 
//处理Student类及其子类对象
if (e instanceof Graduate)
//处理Graduate类及其子类对象
}

十、对象类型转换 (Casting )
1、基本数据类型的Casting：
自动类型转换：小的数据类型可以自动转换成大的数据类型

long g=20;
double d=12.0f

强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型

float f=(float)12.0;
int a=(int)1200L

2、对Java对象的强制类型转换称为造型

从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型
（1）对象类型转换举例

public class ConversionTest {
    public static void main(String[] args) {
        double d = 13.4;
        long l = (long) d;
        System.out.println(l);
        int in = 5;
        // boolean b = (boolean)in;
        Object obj = "Hello";
        String objStr = (String) obj;
        System.out.println(objStr);
        Object objPri = new Integer(5);
        // 所以下面代码运行时引发ClassCastException异常
        String str = (String) objPri;
    }
}

public class ConversionTest {
    public static void main(String[] args) {
        double d = 13.4;
        long l = (long) d;
        System.out.println(l);
        int in = 5;
        // boolean b = (boolean)in;
        Object obj = "Hello";
        String objStr = (String) obj;
        System.out.println(objStr);
        Object objPri = new Integer(5);
        // 所以下面代码运行时引发ClassCastException异常
        String str = (String) objPri;
    }
}

十一、继承成员变量和继承方法的区别
方法具有多态性

成员变量不具备多态性

十二、子类继承父类

若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。

对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

多态是编译时行为还是运行时行为？

如何证明？

//对于多态，调用方法时，在编译期间调用的是父类的方法，在运行期间实际调用的是子类重写的方法，即编译时看左边，运行时看右边

十四、 Object类的使用

/**
 * java.lang.Object类
 * 1、Object类是所有Java类的根父类
 * 2、如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
 * 3、Object类中的功能（属性、方法）就具有通用性
 *      属性: 无
 *      方法: equals() toString() getClass() hashCode() clone() finalize() wait() notify() notifyAll()
 *
 * 4、Object类只声明了一个空参的构造器
 */
public class ObjectTest {
    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.getClass().getSuperclass());
    }
 
}
 
class Order{
 
}

Object类是所有Java类的根父类

如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

public class Person {
...
}

等价于：

public class Person extends Object {
...
}

例如：

method(Object obj){…} //可以接收任何类作为其参数
Person o=new Person();
method(o);

1、Object类中的主要结构

2、== 操作符与equals方法

import java.util.Date;
import java.util.Objects;
 
/**
 *面试题： == 和 equals() 区别
 * 一、回顾 == 的使用、
 * 1、== 是一个运算符
 * 2、可以使用在基本数据类型变量和引用数据类型变量中
 * 3、如果比较的是基本数据类型变量，比较两个变量保存的数据是否相等（不一定类型要相同）
 *    如果比较的是引用数据类型的变量，比较的是两个对象（两个变量保存）的地址值是否相等，即两个引用是否指向同一个对象实体
 * 补充：== 符号使用时，必须保证符号两边的变量类型一致。
 *
 *二、equals()方法的使用
 * 1、equals() 是一个方法
 * 2、只能适用于引用数据类型
 * 3、Object类中equals()的定义：
 *
 *                      public boolean equals(Object obj) {
 *                           return (this == obj);
 *                       }
 *                       说明；Object类中定义的equals()和 == 的作用是相同的
 *
 * 4、像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址值是否相同，而是比较两个对象的“实体内容”（属性）是否相同
 * 5、通常情况下，我们自定义的类如果使用equals()的话，通常也是比较两个对象的“实体内容”是否相同，那么，我们就需要对Object类中的equals()方法进行重写。
 *    重写的原则：比较两个对象的实体内容是否相同
 */
public class _2EqualsTest {
    public static void main(String[] args) {
        //基本数据类型
        int i = 10;
        int j = 10;
        System.out.println(i == j); //true
 
        double k = 10;
        System.out.println(i == k); //true
 
        char c = 10;
        System.out.println(i == c); //true
 
        char c1 = 'A';
        char c2 = 65;
        System.out.println(c1 == c2); //true
 
        //引用数据类型
        Customer customer1 = new Customer("张三", 20);
        Customer customer2 = new Customer("张三", 20);
        System.out.println(customer1 == customer2); //false
 
        String string1 = new String("hello word");
        String string2 = new String("hello word");
        System.out.println(string1 == string2); //false
 
//        String string3 = "hello word";
//        String string4 = "hello word";
//        System.out.println(string3 == string4); //true
 
        System.out.println("-------------------------------------");
        System.out.println(string1.equals(string2));
 
        System.out.println("customer1.equals(customer2): " + customer1.equals(customer2));
 
        Date date1 = new Date(111111111111L);
        Date date2 = new Date(111111111111L);
        System.out.println(date1 == date2);
        System.out.println(date1.equals(date2));
    }
}
 
class Customer{
    private String name;
    private int age;
 
    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
 
    //重写的原则：比较两个对象的实体内容（即：name、age）是否相同
//    @Override
//    public boolean equals(Object object) {
//        if (this == object){
//            return true;
//        }
//        if (object instanceof Customer){
//            Customer customer = (Customer) object;
//
//            if (!this.name.equals(customer.name)){
//                return false;
//            }else if (this.age != customer.age){
//                return false;
//            }else {
//                return true;
//            }
//        }else {
//            return false;
//        }
//    }
 
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Customer customer = (Customer) o;
        return age == customer.age &&
                Objects.equals(name, customer.name);
    }
 
}

（1）== 操作符
基本类型比较值:只要两个变量的值相等，即为true。

int a=5; if(a==6){…}

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true

Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错

（2）equals方法
所有类都继承了Object，也就获得了equals()方法。还可以重写

只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。
格式:obj1.equals(obj2)
特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；

原因：在这些类中重写了Object类的equals()方法。

当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等

（3）重写equals()方法的原则

对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
自反性：x.equals(x)必须返回是“true”。
传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
任何情况下，x.equals(null)，永远返回是“false”；
x.equals(和x不同类型的对象)永远返回是“false”。

（4）面试题：==和equals的区别

== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
具体要看自定义类里有没有重写Object的equals方法来判断。
通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

3、toString()方法

import java.util.Date;
import java.util.Objects;
 
/**
 * Object类中toString()方法的使用
 * 1、当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
 * 2、Object类中toString()的定义
 *                   public String toString() {
 *                      return getClass().getName() + "@" + Integer.toHexString(hashCode());
 *                   }
 *
 * 3、String、Date、File、包装类等都重写了Object类中的toSting()方法
 *  使得在调用对象的toString()方法时，返回“实体内容”信息。
 *
 * 4、自定义类也可以去重写toString()方法，当调用此方法时，返回对象的“实体内容”
 */
public class ToStringTest {
    public static void main(String[] args) {
        ToStringTest toStringTest = new ToStringTest();
        System.out.println(toStringTest.toString());
        System.out.println(toStringTest);
 
        String string = new String("MM");
        System.out.println(string);
 
        Date date = new Date();
        System.out.println(date);
 
        Customer customer = new Customer("张三", 27);
        System.out.println(customer);
 
    }
}
 
class Customer{
    private String name;
    private int age;
 
    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

在进行String与其它类型数据的连接操作时，自动调用toString()方法

Date now=new Date();
System.out.println(“now=”+now); //相当于
System.out.println(“now=”+now.toString());

可以根据需要在用户自定义类型中重写toString()方法
如String 类重写了toString()方法，返回字符串的值。

s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());

基本类型数据转换为String类型时，调用了对应包装类的toString()方法

int a=10; System.out.println(“a=”+a);

十五、包装类的使用

import org.junit.Test;
 
/**
 * 包装类的使用：
 * 1、Java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
 * 2、掌握的：基本数据类型、包装类、String三者之间的转换
 */
public class _1WrapperTest {
 
    /**
     * 基本数据类型 --> 包装类：调用包装类的构造器
     */
    @Test
    public void testWrapper1(){
        int num1 = 10;
//        System.out.println(num1.toString()); //Cannot resolve method 'toString()'
        Integer integer = new Integer(num1);
        System.out.println(integer.toString());
 
        Integer integer1 = new Integer("10");
        System.out.println(integer1);
 
        //报异常
//        Integer integer2 = new Integer("1a"); //java.lang.NumberFormatException: For input string: "1a"
 
        Float aFloat = new Float(10.5); //public Float(double value)
        System.out.println(aFloat);
        Float aFloat1 = new Float(10.5f); //public Float(float value)
        System.out.println(aFloat1);
        Float aFloat2 = new Float("10.5f"); // public Float(@NotNull String s)
        System.out.println(aFloat2);
 
        Boolean aBoolean = new Boolean(true);
        System.out.println(aBoolean);
        Boolean aBoolean1 = new Boolean("true");
        System.out.println(aBoolean1);
        Boolean aBoolean2 = new Boolean("true1"); //忽略大小写情况下 除了true 或者 "true" 其他的全都返回false
        System.out.println(aBoolean2);
 
        //包装类的默认初始化值 和 基本数据类型的初始化值
        Order order = new Order();
        System.out.println(order.isMale); //false
        System.out.println(order.isFemale); //null
    }
 
    /**
     *  包装类 --> 基本数据类型: 调用包装类的xxxValue()方法
     */
    @Test
    public void testWrapper2(){
        Integer integer = new Integer(10);
        int i = integer.intValue();
 
        Float aFloat = new Float(10);
        float v = aFloat.floatValue();
 
        System.out.println(i + v);
 
    }
 
    public void method(Object object){
        System.out.println(object);
    }
 
    /**
     * JDK 5.0 新特性：自动装箱与拆箱
     */
    @Test
    public void testWrapper3(){
        int a = 10;
        method(a);
 
        //自动装箱：基本数据类型 --> 包装类
        int b = 10;
        Integer integer = b; //自动装箱
 
        boolean b1 = true;
        Boolean boolean1 = b1; //自动装箱
 
        //自动拆箱：包装类 --> 基本数据类型
        int a1 = integer;
        boolean b2 = boolean1;
    }
 
    /**
     *基本数据类型、包装类 --> String类型
     */
    @Test
    public void testToString(){
        int num1 = 10;
        //方式1: 连接运算
        String str1 = num1 + "";
        System.out.println(str1);
 
        //方式2: 调用String重载的valueOf()方法
        float f = 20;
        String str2 = String.valueOf(f);
        System.out.println(str2);
 
        Double d = new Double(30);
        String str3 = String.valueOf(d);
        System.out.println(str3);
    }
 
    /**
     * String类型 --> 基本数据类型、包装类: 调用包装类的 parseXxx() 方法
     */
    @Test
    public void TestStringTo(){
        String str1 = "-10";
//        int i1 = (int) str1; //cannot cast 'java.lang.String' to 'int'
//        Integer i2 = (Integer) str1; //cannot cast 'java.lang.String' to 'java.lang.Integer'
        int i = Integer.parseInt(str1);// 1.0 java.lang.NumberFormatException
        System.out.println(i);
 
        boolean b = Boolean.parseBoolean("TruE"); //true
        boolean b1 = Boolean.parseBoolean("TruE1"); //false
        System.out.println(b);
        System.out.println(b1);
    }
 
 
 
}
 
class Order{
    boolean isMale;
    Boolean isFemale;
}

针对八种基本数据类型定义相应的引用类型—包装类（封装类）

有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

1、基本数据类型包装成包装类的实例: 装箱
通过包装类的构造器实现：

int i = 500; Integer t = new Integer(i);

还可以通过字符串参数构造包装类对象：

Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException

2、获得包装类对象中包装的基本类型变量: 拆箱

调用包装类的.xxxValue()方法：
boolean b = bObj.booleanValue();

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
3、字符串转换成基本数据类型
通过包装类的构造器实现：

int i = new Integer(“12”);

通过包装类的parseXxx(String s)静态方法：

Float f = Float.parseFloat(“12.1”);

4、基本数据类型转换成字符串
调用字符串重载的valueOf()方法：

String fstr = String.valueOf(2.34f);

更直接的方式：

String intStr = 5 + “”

5、包装类用法举例

int i = 500;
Integer t = new Integer(i);

装箱：包装类使得一个基本数据类型的数据变成了类。有了类的特点，可以调用类中的方法

String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字

拆箱：将数字包装类中内容变为基本数据类型。

int j = t.intValue(); // j = 500，intValue取出包装类中的数据

包装类在实际开发中用的最多的在于字符串变为基本数据类型。

String str1 = "30" ;
String str2 = "30.3" ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型

6、面试题

import org.junit.Test;
public class _2面试题 {
    /**
     * 第一题、如下两个题目的输出结果相同吗？各是什么：
     */
    @Test
    public void method1(){
        // 三元运算符 : 两边要求结果的数据类型一致 Integer 和 Double 会自动类型提示为 Double
        Object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1); //1.0
 
        Object o2;
        if (true){
            o2 = new Integer(1);
        }else {
            o2 = new Double(2.0);
        }
        System.out.println(o2); //1
    }
 
    /**
     * 第二题
     */
    @Test
    public void method2() {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false == 引用数据类型比较地址值
 
        //Integer 定义了一个IntegerCache结构, 用于初始化一个数值范围为 -128 ~ +127 的Integer[]
        //如果我们使用自动装箱的方式给Integer赋值, 这个范围内的数( -128 ~ +127), 直接使用数组种的元素, 其它的数是new出来的
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true  直接使用数组中的元素
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false 是new出来的
    }
 
}

7、练习

import java.util.Scanner;
import java.util.Vector;
 
/**
 * 利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。
 * 提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。
 * 创建Vector对象：Vector v=new Vector();
 * 给向量添加元素：v.addElement(Object obj); //obj必须是对象
 * 取出向量中的元素：Object obj=v.elementAt(0);
 * 注意第一个元素的下标是0，返回值是Object类型的。
 * 计算向量的长度：v.size();
 * 若与最高分相差10分内：A等；20分内：B等；30分内：C等；其它：D等
 */
public class VectorTest {
    public static void main(String[] args) {
 
        Scanner scanner = new Scanner(System.in);
 
        Vector vector = new Vector();
 
        double maxScore = 0; //最高分
        while (true){
            System.out.print("学生成绩: ");
            double score = scanner.nextDouble();
            if (score < 0){ //负数代表输入结束
                break;
            }
            vector.addElement(score);
            //获取最高分
            if (maxScore < score){
                maxScore = score;
            }
        }
 
        System.out.println();
        System.out.println("数组里面有" + vector.size() + "个元素");
        System.out.println("最高分: " + maxScore);
        for (int i = 0; i < vector.size(); i++){
            double score = (double) vector.elementAt(i);
            double differScore = maxScore - score;
            String level;
            if (differScore <= 10){
                level = "A";
            }else if (differScore <= 20){
                level = "B";
            }else if (differScore <= 30){
                level = "C";
            }else {
                level = "D";
            }
            System.out.println("学生: student" + (i + 1) + ", 分数: " + score + ", 等级: " + level);
        }
    }
}

标签：String,子类,System,OOP2,父类,public,out
From： https://www.cnblogs.com/sylaaa/p/18673953

相关文章

赞助商

阅读排行