大数据--Java面向对象

知识点1：多态的理解

开发中多态的常见场景

public static void main(String[] args) {
        //开发中很少见的多态场景
        Person p1 = new Man();

        System.out.println(p1.id);//属性不存在多态性

        p1.eat();

//        p1.earnMoney();


        PersonTest test = new PersonTest();
        test.method(new Man());//开发中常见的多态的场景
}

public void method(Person p) { //Person p = new Man();
        p.eat();
        p.walk();
        System.out.println(p.id);
}

有了多态之后，编译、运行中出错的情况展示

//###########更多的开发常见问题###################
        //编译不通过
//        Woman w1 = (Woman)new Man();
//        String str = new Date();

        //编译通过，运行不通过
//        Person p2 = new Man();
//        Woman w2 = (Woman)p2;

//        Object obj = new Date();
//        String str = (String)obj;

        Person p2 = new Person();
        Man m2 = (Man) p2;

        //编译通过，运行也通过
        Object obj = new Man();
        Person p3 = (Person) obj;
        p3.eat();

面试题：如何理解面向对象的三大特征？

使用自己的语言组织

尽量多举开发中的例子

封装性就是把普通的对象进行封装，对象的属性设为私有的，对外提供get和set方法，其他类只能通过get和set对对象属性值进行操作。比如，可以将类中属性私有化。继承是发生在两个类之间，一个类继承另一个类是说这个类属于另一个类，具有另一个类的所有属性和方法，同时它还可以有另一个类不具备的方法和属性。比如，定义一个类为账户。多态是建立在继承的基础上的，一个父类对象可以产生多个不同的子类对象，根据这些子类对象的不同可以具备不同的方法，也就是说表现出了不同的形态即多态。

知识点2：Object类

1. 理解

* 1. java.lang.Object是所有其他java类的根父类
* 内部声明的方法具有通用性。
*
* 2. clone():可以看做是创建Java中对象的第二种方式
* 3. finalize()：当垃圾回收器在回收对象前，对象会调用此方法。
面试题：final \ finally \ finalize 三者的区别
4. hashCode():放到后面集合内容讲解
5. wait() / notify() / notifyAll() :放到后面线程通信时讲解

2. equals()的使用

java.lang.Object类的equals()的使用
*
* 1. java.lang.Object类中equals()的声明：
* public boolean equals(Object obj) {
* return (this == obj);
* }
* 说明：Object类中的equals()是比较两个对象的地址值是否相同。（或比较两个引用是否指向堆空间中的同一个对象）
*
* 2. 像String\File\Date类等都重写了Object类中的equals()。重写的规则：
* 比较两个对象的属性值是否都相等。
*
* 3. 自定义类在没有重写Object类的equals()前，比较的都是两个引用的地址值是否相等。
* 但是一般开发中，凡是调用了equals(),都是想比较两个对象的实体内容是否相等。则意味着我们
* 要重写equals().

举例

public class Order {
    private String orderName;
    private int orderId;

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public Order(String orderName, int orderId) {
        this.orderName = orderName;
        this.orderId = orderId;
    }

    public Order() {
    }

    //手动重写equals()：比较两个对象的实体内容是否相等。
//    @Override
//    public boolean equals(Object obj) {
//        System.out.println("Order equals()....");
//        if (this == obj) {
//            return true;
//        }
//        if (obj instanceof Order) {
//            Order order = (Order) obj;
//            //比较当前Order对象this与order对象的实体内容
////            if(this.orderId == order.orderId && this.orderName.equals(order.orderName)){
////                return true;
////            }else{
////                return false;
////            }
//            //可以写为：
//            return this.orderId == order.orderId && this.orderName.equals(order.orderName);
//        }
//
//        return false;
//
//    }

    //自动生成的equals()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Order order = (Order) o;

        if (orderId != order.orderId) return false;
        return orderName != null ? orderName.equals(order.orderName) : order.orderName == null;
    }
    
}

面试题：

面试题： == 和 equals() 的区别？
1. == ： 运算符，适用于基本数据类型(比较两个数据的值是否相等)、引用数据类型(比较两个引用是否指向堆空间中的同一个对象)
2. equals(): 适用于引用数据类型。

3. toString()的使用

1. Object类中toString()的定义：
* public String toString() {
* return getClass().getName() + "@" + Integer.toHexString(hashCode());
* }
* 2. 当我们没有重写Object类中的toString()方法时，当输出对象的引用时，默认调用Object类
* 中的toString()方法，输出对象的地址值。
*
* 3. 像String\日期Date\File类等类型都重写了Object类中的toString()方法，返回其内部的
* 实体内容。
*
* 4. 如果我们希望调用自定义类的toString()时，希望返回其内部实体内容。则需要进行重写。
*

举例

 

package com.atguigu.java1;

/**
 * @author shkstart
 * @create 2020-07-07 10:42
 */
public class Order {
    private String orderName;
    private int orderId;

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public Order(String orderName, int orderId) {
        this.orderName = orderName;
        this.orderId = orderId;
    }

    public Order() {
    }

    //手动生成的：
//    public String toString() {
//        return "Order[orderName : " + orderName + ",orderId : " + orderId + "]";
//    }

    //自动生成的：
    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                '}';
    }
}

知识点3：包装类的使用

1. 我们为8种基本数据类型提供了对应的8种包装类。目的是为了让基本数据数据类型的变量
* 具备类的特征 ---> 便于一些方法调用时使用。

2. 掌握8种基本数据类型以及对应的包装类。

 

3. 掌握：基本数据类型、包装类、String类三者之间的转换操作

 

测试举例

/*
    基本数据类型---> 对应的包装类：

    包装类 ---> 基本数据类型：
     */
    @Test
    public void test1(){
        //基本数据类型---> 对应的包装类：调用包装类的构造器
        int m = 10;
        Integer integer1 = new Integer(m);
        System.out.println(integer1.toString());

        float f1 = 10.2F;
        Float float1 = new Float(f1);

        String s1 = "10.3";
        Float float2 = new Float(s1);
        System.out.println(float2.toString());

        //包装类 ---> 基本数据类型：调用包装类的xxxValue()
        int j = integer1.intValue();
        System.out.println(j + 0);

        float f2 = float2.floatValue();

    }

    //JDK5.0引入的新特性：自动的装箱和拆箱
    @Test
    public void test2(){
        int m = 10;
        Integer int1 = m;//自动装箱
        Integer int2 = 10;//自动装箱
        System.out.println(int1.toString());

        method(10);//自动装箱

        int n = int1;//自动拆箱
        int sum = int1 * 20;//自动拆箱

        test1(int2);//自动拆箱
    }

    public void method(Object obj){
        System.out.println(obj);
    }

    public void test1(int i){

    }

    /*
    基本数据类型、包装类 --> String类型：
    String类型 ---> 基本数据类型、包装类：
     */
    @Test
    public void test3(){
        //基本数据类型、包装类 --> String类型: ① 调用String重载的valueOf(Xxx xx) ② 连接符：+
        int num = 10;
        Float f1 = new Float(10.1);

        String s1 = String.valueOf(num);
        String s2 = String.valueOf(f1);

        System.out.println(s1);
        System.out.println(s2);

        String s3 = num + "";

    }

    @Test
    public void test4(){
        String s1 = "123";
//        s1 = "123abc";//会报NumberFormatException
//        String类型 ---> 基本数据类型、包装类：调用包装类Xxx的parseXxx()
        Integer int1 = new Integer(s1);

        int i = Integer.parseInt(s1);

        String s2 = "true123";
        s2 = "TruE";
        boolean b = Boolean.parseBoolean(s2);

        System.out.println(i);
        System.out.println(b);

    }
}

简化为：

JDK5.0引入的新特性：自动的装箱和拆箱.可以实现基本数据类型和包装类之间的转换
基本数据类型、包装类 --> String类型: ① 调用String重载的valueOf(Xxx xx) ② 连接符：+
String类型 ---> 基本数据类型、包装类：调用包装类Xxx的parseXxx()

 

补充说明

class Order{
    boolean isMale;
    Boolean isMarried;
}
class Account{
    double balance;//0.0
    Double balance1;//null
}
//测试时：
@Test
    public void test5(){
        Order order = new Order();
        System.out.println(order.isMale);//false
        System.out.println(order.isMarried);//null
    }

知识点4：单元测试方法

/**
 * 单元测试方法的使用
 *
 * 1. 为什么使用单元测试方法：为了方便的在测试类中针对多个不同的代码或方法单独进行测试。
 *
 * 2. 如何实现？有什么要求？
 *  ① 单元测试方法声明前加上注解： @Test (来自于org.junit.Test)
 *  ② 单元测试方法是：public的、无返回值类型的、无形参的方法
 *  ③ 单元测试类是public的，提供空参的public权限的构造器
 *
 *  如果以上条件不满足，在执行单元测试方法时，报initializationError
 *
 * @author shkstart
 * @create 2020-07-07 15:22
 */
public class JUnitTest { //单元测试类

    @Test
    public void test1(){  //单元测试方法
        System.out.println("hello");
        int m = 10;
        int n = 20;
        System.out.println( m + n);
    }

    @Test
    public void test2(){
        int m1 = 10;
        int n1 = 10;
        System.out.println(m1 == n1);//true
        int m2 = 65;
        char c1 = 'A';
        System.out.println(m2 == c1);//true
        float f1 = 65.0F;
        System.out.println(m2 == f1);//true
    }

    @Test
    public void testGet(){
        int sum = get(10,20);
        System.out.println(sum);
    }


    public int get(int m,int n){
        return m + n;
    }

}

补充：关于String字符串常量池的使用

public class StringTest {
    public static void main(String[] args) {
        //通过字面量的方式进行字符串的赋值操作。此时的字符串数据保存在字符串常量池中。
        //字符串常量池中，不存在内容相同的字符串。
        String s1 = "hello";//字面量赋值的方式
        String s2 = "hello";
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s1.equals(s2));//true


        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

    }
}