Java--类与反射（笔记）

最新推荐文章于 2024-08-18 21:36:31 发布

程序员清羽

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量153

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/l396465/article/details/126081752

版权

一、类、超类和子类

1.定义子类

class People{
    private String name;
    private int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "name=" + name + " age="+ age;
    }
    public void action(){
        System.out.println("呼吸");
    }
}
class Student extends  People{

    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public String toString() {
        return super.toString();
    }

    public void action(){
        System.out.println("学习");
    }
}
class Teacher extends  People{
    public Teacher(String name, int age) {
        super(name, age);
    }

    public void action(){
        System.out.println("教学");
    }


}

2.覆盖方法

当父类的某个方法不适用于其子类的时候，我们需要提供新的方法来覆盖父类的方法。

3.子类构造器

由于Student类的构造器不能访问 People类的私有字段，所以必须通过一个构造器来初始化这些私有字段。可以利用特殊的 super 语法调用这个构造器。使用super调用构造器的语句必须是子类构造器的第一条语句。
如果子类的构造器没有显式地调用超类的构造器，将自动地调用超类的无参数构造器,如果超类没有无参数的构造器，并且在子类的构造器中又没有显式地调用超类的其他构器，Java编译器就会报告一个错误。

4.多态

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。


class People{
    public void action(){
        System.out.println("呼吸");
    }
}
class Student extends  People{
    public void action(){
        System.out.println("学习");
    }
}
class Teacher extends  People{
    public void action(){
        System.out.println("教学");
    }

}

public class Md {
    public static void main(String[] args) {
        People p1 = new Student();
        People p2 = new Teacher();
        p1.action();//学习
        p2.action();//教学
    }
}

5.阻止继承：final类和方法

final class T1{}//t1不能被继承

class T2{
    String name;
    public final String getName(){//getName不能被覆盖
        return name;
    }
}

6.抽象类

抽象方法充当着占位方法的角色，它们在子类中具体实现。扩展抽象类可以有两种选。一种是在子类中保留抽象类中的部分或所有抽象方法仍未定义，这样就必须将子类标记为抽象类;另一种做法是定义全部方法，这样一来，子类就不是抽象的了。

abstract class Person{
    abstract void getDescription();
}

class Student extends Person{
    abstract void getDescription(
        System.out.println("学习");
    )
}

二、Object：所有类的超类

在Java中所有的类都扩展了Object，如果没有明确指出超类，Object就被认为是这个类的超类。

1.Object类型的变量

Object[] object = new Integer [3];

2.equals方法

Object类中的equals方法用于检测一个对象是否等于另外一个对象。Object类中实现的 equals方法将确定两个对象引用是否相等。这是一个合理的默认行为:如果两个对象引用相等，这两个对象肯定就相等。对于很多类来说，这已经足够了。例如，比较两个 PrintStreai对象是否相等并没有多大的意义。不过，经常需要基于状态检测对象的相等性，如果两个对象有相同的状态，才认为这两个对象是相等的。

public boolean equals(Object obj) {
        return (this == obj);
}

People p1 = new Student()；
People p2 = new Teacher();
System.out.println(p1.equals(p2));//false

对于没用重写Object的equals()方法的类型所生成的对象的比较，equals()和==是效果一样的，==比较的是两个变量所指向的对象在内存中指向的地址是否一样，而当两个变量的类型中继承了Object的equals()方法的时候，由于该方法比较的标准是看哈希码是否相等，而哈希码是由hashCode()方法生成的，该方法生成哈希码的依据是对象在内存中的地址，最终比较的还是地址。（参考二--5）

3.相等测试与继承

Java语言规范要求equals方法具有下面的特性:

自反性:对于任何非空引用x，x.equals(x) 应该返回 true。
对称性:对于任何引用x和 y，当且仅当y.equals(x) 返回 true 时，x.equals(y)返回 true。
传递性:对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true, x.equals(z)也应该返回true。
一致性:如果x和y引用的对象没有发生变化，反复调用x.equals(y)应该返回同样的结果。
对于任意非空引用x，x.equals(null)应该返回 false。

4.hashCode方法

散列：散列也叫散列函数，是一种可以将任意长度的输入转换为固定长度输出的算法，因此不同的输入可能产生相同的输出。
散列码：散列码就是按照散列函数生成的结果。

字符串s与t有相同的散列码，这是因为字符串的散列码是由内容导出的。而字符串构建器sb与tb却有着不同的散列码，因为在StringBuilder类中没有定义hashCode方法，而Object 类的默认 hashcode方法会从对象的存储地址得出散列码。

Object的hashCode()方法返回的哈希码是根据对象的内存地址来生成的，所以每个对象的哈希码是不相同的，如果你要比较的两个变量的类型没有重写Obiect的hashCode()方法那么这两个变量除非是指向相同的对象(地址相同)，否则返回的一定是false。而String以及基本数据类型的包装类中都重写了 hashCode()方法，他们生成的哈希码是跟他们的内容(这里就是指值)息息相关，也就是说在用equals()比较两个变量是否相等的时候只要他们的值相等，那么就返回true，因为他们生成的哈希码相等。

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

String s = "fss";
String ss = new String("fss");
StringBuilder sss = new StringBuilder("fss");
System.out.println(s.hashCode());//101702
System.out.println(ss.hashCode());//101702
System.out.println(sss.hashCode());//460141958

5.toString

    public String toString() {
        return "name=" + name + " age="+ age;
    }

三、泛型数组列表

1.声明数列列表

这个方法调用将分配一个包含100个对象的内部数组。这样一来，前 100 次 add 调用不会带来开销很大的重新分配空间。另外，还可以把初始容量传递给ArrayList构造器:

ArrayList<E>list = new ArrayList<>();
list.ensureCapacity(100);
ArrayList<E> list =new ArrayList<>(100);

2.访问数组列表元素

list.get(i);
list.set(i,10086);

四.对象包装器和自动装箱

在ArrayList<E>中，E是不能为int,double,long等基本类型的，要使用对应的包装类，例如int类型应该使用Integer。而包装类是不可变的，一旦构造了包装类，就不能改变包装在里面的值，而且包装器的类是fianl，不能派生子类。在日常代码中会发现有直接更改包装里面的值，但只是表面是起来而已。

Integer i = 4;
i = i + 4;//i = 8;

这种情况是因为在运算前，编译器会先给包装类的 “i” 进行拆箱，使其变为基本类型，然后再进行运算，最后再将 “i” 装箱。

//调用
list.add(3);
//会自动变成
list.add(Integer.valuOf(3));
//也就是自动装箱。

在比较包装类对象的值是否相等时候应该调用equal（）方法，因为==是比较对像的内存地址。

Integer i = 1000,b = 1000;
System.out.println(i==b);//结果为false