java核心技术读书笔记(第四天：继承)-CSDN博客

本文链接：https://blog.csdn.net/m0_57538148/article/details/124087423

继承👀

1.类、超类和子类🌦

子类调用超类的同名方法

super.getSalary();

子类构造器

public Manager(String name,double salary){
    super(name,salary);
    bonus=0;
}

如果子类构造器没有显示的调用超类构造器，将自动调用超类的无参构造器，如果超类再没有无参构造器，编译器将会报错
this：隐式参数的引用，调用该类的其他构造器
super：调用超类的方法，调用超类的构造器

多态：一个变量可以指示多种实际类型的现象

多态的实例

class A {
    public String show(D obj) {
        return ("A and D");
    }
    public String show(A obj) {
        return ("A and A");
    }
}

class B extends A {
    public String show(B obj) {
        return ("B and B");
    }
    public String show(A obj) {
        return ("B and A");
    }
}

class C extends B {}
class D extends B {}

思考以下结果输出什么？

A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();

System.out.println("1" + a1.show(b));
System.out.println("2" + a1.show(c));
System.out.println("3" + a1.show(d));
System.out.println("4" + a2.show(b));
System.out.println("5" + a2.show(c));
System.out.println("6" + a2.show(d));
System.out.println("7" + b.show(b));
System.out.println("8" + b.show(c));
System.out.println("9" + b.show(d));
System.out.println("10" + a2.show(a1));

答案：

A and A
A and A
A and D
B and A
B and A
A and D
B and B
B and B
A and D
A and A

实例来源：https://blog.csdn.net/weixin_36637758/article/details/95089175

动态绑定：运行时能够自动地选择适当的方法

阻止继承：类声明添加final关键字，也可在方法上添加阻止覆盖

强制转换前：

if(staff[1] instanceof Manager){
    boss=(Manager)staff[1];
    ···
}

抽象类：加入关键字abstract，抽象类可以包含字段和具体方法

子类继承抽象类时除非声明了为抽象类否则要实现超类的所有方法

子类不能访问超类的私有private字段（但是通过反射可以破坏这种关系）

4个控制修饰符：

privata	本类完全可见
protected	本包所有子类可见
default	本包可见
public	外部完全可见

2.Object🌧

Object是java中所有类的始祖

Object类型的变量

可以使用Object类型的变量引用任何类型的变量

Object obj=new Employee("Harry Hacker",35000);
//Object类型的变量只能作为各种值的一个泛型容器
Employee e=(Employee)obj;

equals方法

Object类中的equals方法用于检测一个对象是否等于另一个对象，是判断两个对象引用指向的是同一个对象，即比较 2 个对象的内存地址是否相等

class RunoobTest {
    public static void main(String[] args) {
        // Object 类使用 equals() 方法
        // 创建两个对象
        Object obj1 = new Object();
        Object obj2 = new Object();
 
        // 判断 obj1 与 obj2 是否相等
        // 不同对象，内存地址不同，不相等，返回 false
        System.out.println(obj1.equals(obj2)); // false
 
        // obj1 赋值给 obj3
        // String 重写了 equals() 方法
        // 对象引用，内存地址相同，相等，返回 true
        Object obj3 = obj1;
        System.out.println(obj1.equals(obj3)); // true
    }
}

java.util.Arrays下的equals方法如果两个数组长度相同，对应位置上数据元素也相同将返回true

static boolean equals(xxx[] a,xxx[] b)

hashCode方法

Object hashCode() 方法用于获取对象的 hash 值。

语法:

object.hashCode()

返回值：返回对象哈希值，是一个整数，表示在哈希表中的位置。

以下实例演示了 hashCode() 方法的使用：

import java.util.ArrayList;
 
class RunoobTest {
    public static void main(String[] args) {
 
        // String 使用 hashCode()
        String str = new String();
        System.out.println(str.hashCode()); // 0
 
        // ArrayList 使用 hashCode()
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println(list.hashCode()); // 1
    }
}

如果两个对象相等，则它们的哈希值也是相等的：

class RunoobTest {
    public static void main(String[] args) {
 
        // Object 使用 hashCode()
        Object obj1 = new Object();
 
        // obj1 赋值给 obj2
        Object obj2 = obj1;
 
        // 判断两个对象是否相等
        System.out.println(obj1.equals(obj2)); // true
 
        // 获取 obj1 与 obj2 的哈希值
        System.out.println(obj1.hashCode()); // 225534817 
        System.out.println(obj2.hashCode()); // 225534817
 
    }
}

toString

Object toString() 方法用于返回对象的字符串表示形式。

语法：

object.toString()

默认返回格式：对象的 class 名称 + @ + hashCode 的十六进制字符串。(不重写toString方法时)

toString() 方法的使用：

class RunoobTest {
    public static void main(String[] args) {
 
        // toString() with Object
        Object obj1 = new Object();
        System.out.println(obj1.toString());
 
        Object obj2 = new Object();
        System.out.println(obj2.toString());
 
        Object obj3 = new Object();
        System.out.println(obj3.toString());
    }
}

//java.lang.Object@d716361
//java.lang.Object@6ff3c5b5
//java.lang.Object@3764951d

clone

Object clone() 方法用于创建并返回一个对象的拷贝。

clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建。

语法：

object.clone()

返回值：返回一个对象的拷贝。

由于 Object 本身没有实现 Cloneable 接口，所以不重写 clone 方法并且进行调用的话会发生 CloneNotSupportedException 异常。

以下实例创建了 obj1 对象，然后拷贝 obj1 给 obj2，通过 obj2 输出变量的值：

class RunoobTest implements Cloneable {
 
    // 声明变量
    String name;
    int likes;
 
    public static void main(String[] args) {
 
        // 创建对象
        RunoobTest obj1 = new RunoobTest();
 
        // 初始化变量
        obj1.name = "Runoob";
        obj1.likes = 111;
 
        // 打印输出
        System.out.println(obj1.name); // Runoob
        System.out.println(obj1.likes); // 111
 
        try {
 
            // 创建 obj1 的拷贝
            RunoobTest obj2 = (RunoobTest) obj1.clone();
 
            // 使用 obj2 输出变量
            System.out.println(obj2.name); // Runoob
            System.out.println(obj2.likes); // 111
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

3.泛型数组列表⛈

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素

声明：

ArrayList<Employee> staff=new ArrayList<>();
ArrayList<Employee> staff=new ArrayList<>(100);	//指定大小，仍可以再变
//或
var staff=new ArrayList<Employee>();

4.对象包装器与自动装箱🌩

var list=new ArrayList<Integer>();

自动装箱：调用list.add(3)将自动变换为list.add(Integer.valueof(3));

自动拆箱：int n=list.get(i)自动变换成int n=list.get(i).intValue();

自动装箱要求：boolean、byte、char<=127,介于-128～127之间的short、int会被包装到固定的对象

装箱和拆箱是编译器要做的工作，而不是虚拟机

将字符串转换为整型：int x=Integer.parseInt(s);

5.参数数量可变的方法🌨

public static double max(double... values){
    double largest=Double.NEDATIVE_INFINITY;
    for(double v:values) if(v>largest) largest=v;
    return largest;
}

调用：double m=max(3.1,40.4,-8);

6.反射☁️

class类

获得class对象：

Employee e;
Class c1=e.getClass();	//通过对象获得
c1.getName();	//获得name属性

String className="java.util.Random";
Class c1=Class.forName(className);		//通过forname获得

Class c1=Random.class;		//通过类名获得
Class c2=int.class;

🧱后续待更。。。