大数据--Java面向对象

 

项目：客户关系管理系统（略）

• 项目中不包含新知识点

• 项目的业务逻辑相较于普通的练习来说，更复杂一些。

 

知识点1：子类对象实例化的过程

1. 从结果上来说：体现为类的继承性
* 子类继承父类以后，当创建子类对象时，堆空间中除了会加载子类自己特有的属性之外，还会加载其所有的父类
* 中的属性。当权限允许的情况下，子类对象可以调用父类的属性。
*
* 2. 从过程上来看：
* 当我们子类构造器创建子类对象时，一定会直接或间接的调用其父类的构造器，乃至于父类的父类的构造器，。。。
* 直到调用了java.lang.Object类的构造器。由于我们加载过子类的所有的父类的构造器，所有，我们在堆空间
* 中就存在子类及其所有父类中声明的属性了。
*
* 3. 明确：此时在内存空间中，只存在唯一的一个对象。即为new后面子类的对象。

 

知识点2：多态性及其应用

what?

面向对象的特征之三：多态性的使用
*
* 1.多态性：一个事物的多种形态。
*
* 2.广义上的多态性：① 方法的重写 ② 子类对象的多态性
*
* 3. 子类对象的多态性：父类的引用指向子类的对象。（或子类的对象赋给父类的引用）

 

how？

4. 子类对象的多态性的应用：虚方法调用（virtual method）
* 编译时，引用变量p2只能调用父类声明的方法。当运行时，实际执行的是子类重写父类的方法。
* 简称：编译看左边，运行看右边。
*
* 5. 子类对象的多态性使用的前提：① 类的继承性 ② 方法的重写
*
* 6. 子类对象的多态性不适用于属性、构造器。

 

对应的代码

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        Man m1 = new Man();

        p1.eat();
        p1.walk();

        m1.eat();
        m1.earnMoney();

        int i = 10;
        float f = 10.0F;

        //自动类型提升
        double d = 10;
        System.out.println("#######################");

        //子类对象的多态性
        Person p2 = new Man();

        //多态性的应用：虚方法调用（virtual method）
        //编译时，引用变量p2只能调用父类声明的方法。当运行时，实际执行的是子类重写父类的方法。
        p2.eat();
        p2.walk();
        //编译不通过。
//        p2.earnMoney();

        System.out.println(p2.id);//1001
    }
}

其中，相关的类定义如下：

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2020-07-06 15:35
 */
public class Person {
    String name;
    int age;
    int id = 1001;

    public void eat(){
        System.out.println("人：吃饭");
    }

    public void walk(){
        System.out.println("人：走路");
    }
}

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2020-07-06 15:39
 */
public class Woman extends Person {

    boolean isBeauty;

    public void eat(){
        System.out.println("女人：少吃饭，减肥");
    }

    public void walk(){
        System.out.println("女人：窈窕的走路");
    }

    public void goShopping(){
        System.out.println("女人心情不好使，一逛街就心情愉悦");
    }
}
package com.atguigu.java;

/**
 * @author shkstart
 * @create 2020-07-06 15:36
 */
public class Man extends Person {

    boolean isSmoking;
    int id = 1002;

    public void eat(){
        System.out.println("男人：多吃肉，长肌肉");
    }

    public void walk(){
        System.out.println("男人：笔挺的走路");
    }

    public void earnMoney(){
        System.out.println("男人挣钱养家...");
    }

}

why?

package com.atguigu.java;

/**
 * 多态性的使用举例
 *
 * @author shkstart
 * @create 2020-07-06 16:18
 */
//举例一：
public class AnimalTest {

    public static void main(String[] args) {
        AnimalTest test = new AnimalTest();
//        test.func(new Animal());
        test.func(new Dog());
        test.func(new Cat());
    }

    public void func(Animal animal) {//Animal animal = new Dog()
        animal.eat();
        animal.shout();

        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.protectHouse();

        }else if(animal instanceof Cat){
            Cat cat = (Cat)animal;
            cat.catchMouse();
        }


//        animal.protectHouse();
    }
    //省略了重载的方法的定义。
//    public void func(Dog dog){
//        dog.eat();
//        dog.shout();
//    }
//
//    public void func(Cat cat){
//        cat.eat();
//        cat.shout();
//    }
}

class Animal {

    public void eat() {
        System.out.println("动物进食");
    }

    public void shout() {
        System.out.println("动物叫~~");
    }

}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void shout() {
        System.out.println("汪~汪~汪~");
    }

    public void protectHouse() {
        System.out.println("狗能看门");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼~");
    }

    public void shout() {
        System.out.println("喵~喵~喵~");
    }

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

//举例二：
/*
class Customer{
    private Account acct;

    public void setAccount(Account acct){ //Account acct = new CheckAccount()
        this.account = account;
    }



}

class Account{
    double balance;

    //存钱、取钱
}

class SavingAccount extends Account{}

class CheckAccount extends Account{}




 */

//举例三：
/*
java.lang.Object类中定义的方法：
public boolean equals(Object obj){}


 */

//举例四：使用jdbc技术操作数据库：mysql\oracle\db2\sqlserver\....
//比如:jdbc中涉及一个父类：Connection。及其内部的一些关于操作数据库的通用方法。
/*
public void operateData(Connection conn){
      //通过conn获取连接、传送sql语句、执行、....
}


 */

知识点3：向下转型

 

 

 

//可以考虑将声明为父类引用的子类对象，通过强转符的方式，将父类的引用再转为子类的引用
        Man m2 = (Man)p2;
        m2.isSmoking = true;
        m2.earnMoney();
        //强转时，可能出现类型转换异常：ClassCastException
//        Woman w1 = (Woman)p2;
//        w1.goShopping();
//        w1.isBeauty = true;

        //向下转型
        //为了避免在强转时出现ClassCastException，我们在强转前，使用instanceof 进行判断即可。
        /*
        格式：a instanceof A：判断对象a是否是类型A的一个实例。
              如果是，返回true。如果不是,返回false。

        补充：如果a instanceof A返回true,则a instanceof B也一定返回true。其中，类型B是类型A的父类。
         */
        Person p3 = new Woman();
        if(p3 instanceof Woman){
            Woman w2 = (Woman) p3;
            System.out.println("可以转换为Woman");
        }

        if(p3 instanceof Man){
            Man m3 = (Man) p3;
            System.out.println("可以转换为Man");
        }

        if(p3 instanceof Person){
            System.out.println("person .....");
        }
        if(p3 instanceof  Object){
            System.out.println("Object...");
        }