实验室后端考核

Integer

赋值的方式创建Integer对象

Integer类型再比较大小的时候调用了Integer.valueOf()方法，-128~127之间的数，比较数值大小的时候用**equals.()和得到的结果是一样的，超出了这个范围，**比较大小就相当于判断是否是同一个对象

Integer和int比较大小会自动拆箱，比较的是数值

public class Test {
    public static void main(String[] args) {
        Integer a = new Integer(3);
        int a1 = 3;
        Integer b = new Integer(300);
        int b1 = 300;
        System.out.println(a == a1);
        System.out.println(a.equals(a1));
        System.out.println(b== b1);
        System.out.println(b.equals(b1));
    }
}

Integer类型大小的比较

    public static void main(String[] args) {
        Integer  a = 1 ;
        Integer  b = 1 ;
        System.out.println(a == b);
        System.out.println(a.equals(b));
        a = 1111;
        b = 1111;
        System.out.println(a == b);
        System.out.println(a.equals(b)); 
    }  

得到的答案：

true
true
false
true

使用new的方式创建Integer对象

只要创建出来就是不同的对象，使用**==无法判断，只能使用equals**方法判断

    @Test
    public void IntegerTest() throws Exception {
        Integer a0 = new Integer(1);
        Integer b0 = new Integer(1);
        System.out.println(a0==b0);
        System.out.println(Objects.equals(a0,b0));
        Integer a1 = new Integer(1111);
        Integer b1 = new Integer(1111);
        System.out.println(a1==b1);
        System.out.println(Objects.equals(a1,b1));
    }

得到的答案

false
true
false
true

构造方法(构造器)

构造方法又叫构造器

一个类必须有构造器，如果没有写构造方法，则会默认存在一个无参构造器

当存在继承关系时，每创建一个子类对象，会触发父类构造器

class Fu{
    public Fu() {
        System.out.println("父类构造器执行");
    }
}
class Zi extends Fu{
    public Zi() {
        //super(); 默认会有
        System.out.println("子类构造器执行");
    }
}
public class Test {
    public static void main(String[] args) {
        Fu test = new Zi();
    }
}

子类和父类之间"沟通"用super关键字

class Fu{
    public Fu() {
        System.out.println("父类构造器执行");
    }
    public  void run(){
        System.out.println("父类的run方法");
    }
}
class Zi extends Fu{
    public Zi() {
        //super(); 默认会有
        System.out.println("子类构造器执行");
    }
    public void run(){
        super.run();
        //System.out.println("子类的run方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Fu test = new Zi();
        test.run();
    }
}

接口

Java不支持多重继承，有了接口，就可以实现多重继承的效果。

接口是抽象方法和常量值定义的集合，接口中只能有抽象方法和常量值，不能有非抽象方法。方法和属性默认都是public修饰，不能使用private修饰符。

所有属性都是静态常量，默认省略了static final修饰符，属性的值必须初始化。

解耦中所有方法默认都是public abstract修饰的。

接口没有构造方法（构造器），所以不能创建对象。

接口使用extend可以继承其他接口，实现类可以实现多个接口。

public interface animal {
    public static final int a = 10;//前面都可以省略
    int b = 20;
    public abstract void run();//发灰说明可以省略
    void fly();
}
class Dog implements animal{

    @Override
    public void run() {
        System.out.println("狗在跑");
    }

    @Override
    public void fly() {
        System.out.println("狗不会飞");
    }
}

class test{
    public static void main(String[] args) {
        Dog d = new Dog();
        int a = animal.a;
        System.out.println(animal.b);
        d.fly();
        d.run();
    }
}

抽象类

抽象类自身拥有构造器，作用是对自身进行初始化，供子类使用

抽象类类前和抽象方法前都用abstract修饰，抽象类中可以有抽象方法，也可以有普通方法，接口中必须全是抽象方法

public class Test {
    public static void main(String[] args) {
        Animals dog = new Dog();
        dog.run("一只小狗");
        dog.run();
    }
}
class Dog extends Animals{

    @Override
    public void run() {
        System.out.println("一群小狗在跑");
    }
}
abstract class Animals {
    public abstract void run();
    public void run(String name){
        System.out.println(name+"在跑");
    }
}

代码块

代码块的执行顺序：静态代码块>main方法>普通代码块>构造方法>普通方法

static代码块只在类加载的时候执行，所以只会执行一次

普通代码块每创建一个对象就会执行一次，构造器每创建一个对象跟在普通代码块之后执行一次

public class Test {
    static {
        int a = 0;
        System.out.println("++++Test类static代码块被执行");
    }

    public static void main(String[] args) {
        System.out.println("++++main方法被执行");
        student s = new student();
    }

}

class student {
    private int age;

    static {
        System.out.println("====学生类static代码块被执行");
    }

    {
        this.age = 10;
        System.out.println("====学生类普通代码块被执行");
    }

    public student() {
        System.out.println("====学生类构造器被执行");
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "student{" +
                "age=" + age +
                '}';
    }
}

StringBuilder和StingBuffer

操作方面StringBuilder和StingBuffer的方法都差不多

public class Test {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("刘备");
        sb.append("张飞");
        sb.append("关羽");
        System.out.println(sb);
        sb.reverse();
        System.out.println(sb);
    }
}

点进去StringBuffer有synchronized修饰，多线程操作安全，性能方面StingBuilder远大于StringBuffer，不涉及线程安全问题一般用StringBuilder