Java知识点锦集1

⭐️大一小何，还在学习当中，欢迎交流指正~

一，super关键字

super的使用:调用属性和方法

1，我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。通常情况下，我们习惯省略"super. "

2，特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

3，特殊情况:当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式,表明调用的是父类中被重写的方法。

super调用构造器
1，我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

2， "super(形参列表)"的使用，必须声明在子类构造器的首行!

3，我们在类的构造器中，针对于"this（形参列表)"或"super (形参列表)"只能二选一，不能同时出现

4，在构造器的首行，没有显式的声明"this(形参列表)"或"super (形参列表)"，则默认调用的是父类中空参的构造者

5，在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

如果是这样的写法，那么，第一个输出的就是子类中的值，第二个调用的就是父类中的变量

二，子类对象实例化全过程

1．从结果上来看:（继承性)

子类继承父类以后，就获取了父类中声明的属性或方法。
创建子类的对象,在堆空间中，就会加载所有父类中声明的属性。

2．从过程上来看:
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器,直到调用了java.lang.object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

注意:虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

三，虚拟方法调用

虚拟方法调用(Virtual Method Invocation)正常的方法调用

Person e = new Person();e.getlnfo();

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

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

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

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

四，object类

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

public class Person {

}

等价于:

public class Person extends Object {

...
例emmm: method(Object obj)...}//可以接收任何类作为其参数

Person o=new Person();
method(o);

看这个代码

public class ObjectTest i
    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.getClass( ).getSuperclass( ));
    }
}

输出结果如下

五，==与equals（）区别

回顾==的使用:
==:运算符
1．可以使用在基本数据类型变量和引用数据类型变量中

2．如果比较的是基本数据类型变量:比较两个变量保存的数据是否相等。(不一定类型要相同)
如果比较的是引用数据类型变量:比较两个对象的地址值是否相同

举个栗子

public class EqualsTest {
    public static void main( String[] args) {
        int i = 10;
        int j = 10;
        double d = 10.0;
        system.out.println(i == j); //true
        System.out.println(i == d);//true
        boolean b = true;

       // System.out.println(i == b);
        char c = 10;
        system.out.println(i == c); //true
        char c1 = 'A';

        char c2 = 65;

        System.out.println(c1 == c2); //true
    }
}

    customer cust1 = new Customer( "Tom",21);
    customer cust2 = new Customer( "Tom",21);
    System.out.println(cust1 == cust2); //false

重写equajis()方法的原则

对称性:如果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和ly内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
任何情况下，x.equals(null)，永远返回是“false”; null.equals(x);x.equals(和x不同类型的对象)永远返回是“false”。//空指针异常

看一道面试题

六，equals（）方法用法

equals()方法的使用:

1．是一个方法，而非运算符

2．只能适用于引用数据类型

3.Object类中equals()的定义:

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

说明: object类中定义的equals()和==的作用是相同的:比较两个对象的地址值是否相同，即两个引用是否指同一个变量

4．像String、Date、File、包装类等都重写了0bject类中的equals()方法。重写以后，比较的不是
两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。

七，自动装箱与自动拆箱

直接上代码说明

public class wrapperTest {

//string类型--->基本数据类型、包装类:调用包装类的parseXxx(String s)
    @Test
    public void test(){
        string str1 = "123";
     // int num1 = (int)str1;//错误的情况
    //  Integer in1 = (Integer)str1;//错误的情况
        int num2 = Integer.parseInt(str1);
        System.out.print1n(num2 +1);//124
        String str2 = "true ;
        boolean b1 = Boolean.parseBoolean(str2);
        system.out.print1n(b1);//true
}

public class wrapperTest i
//基本数据类型、包装类-->String类型:调用String重载的valueOf(Xxx xxx)
    @Test
    public void test(){
        int num1 = 10;
    //方式1:连接运算
        string str1 = num1 +"";
    //方式2:调用String的valueof(Xxx xxX)
        float f1 = 12.3f;
        string str2 = String.valueof(f1);//"12.3"
        Double d1 = new Double(12.4);
        string str3 = String.vaLueof(d1);System.out.print1n(str2);
        system.out. print1n(str3);/l//"12.4"
}

public class wrapperTest {
//包装类-->基本数据类型:调用包装类×xx的X×xValue()
    @Test
    public void test2(){
        Integer in1 = new Integer(12);
        int i1 = in1.intvalue();
        system.out.print1n(i1 +1);
        Float f1 = new Float(12.3);
        float f2=f1.floatValue();
        system.out.print1n(f2 + 1);
    }
}

public void test(){
   // int num1 = 10;
//基本数据类型-->包装类的对象
//method ( num1);
//自动装箱。基本数据类型--->包装类
        int num2 =10;
        Integer in1 = num2;//自动装箱

        boolean b1 = true;
        Boolean b2 = b1;//自动装箱
//自动拆箱。包装类--->基本数据类型
    System.out.println(in1.toString());
    int num3 = in1;//自动拆箱
    }
}

八，包装类的使用

看一道面试题

public class InterviewTest {

    @Test
    public void test1(){
        object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1);//1.0
     }
    @Test
    public void test2( ) {
        object o2;
      if (true)
        o2 = new Integer(1);
    else
        o2 = new Double(2.0);
      system.out.print1n(o2);//1
    }
}

为什么会出现这样的结果？因为在用三元表达式时，为了进行比较，第一个表达式会进行自动类型提升，而第二题不会，直接输出就ok啦。

九，单元测试方法的使用

java中的Junit单元测试
步骤：
1.选中当前工程-右键选择:build path - add libraries - JUnit5 -下一步

2.创建Java类,进行单元测试。
此时的Java类要求:此类是public的@此类提供公共的无参的构造器

3.此类中声明单元测试方法。
此时的单元测试方法:方法的权限是public,没有返回值，没有形参

4.此单元测试方法上需要声明注解:@Test,并在单元测试类中导入。 import org.junit.Test;

5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。

6.写完代码以后，左键双击单元测试方法名，右键:run as - JUnit Test

说明:

1.如果执行结果没有任何异常:绿条
2.如果执行结果出现异常:红条

图示说明（eclipse）

接下来就可以进行测试了。

冲冲冲~