【学习笔记】Java中一些要注意的点

类型

装箱和拆箱

装箱过程就是通过包装器的 valueOf() 方法实现的，而拆箱过程是通过调用包装器的 xxxValue() 方法实现的。

由于valueOf()的实现中，Byte、Short、Integer、Long和Character有缓存机制，cache数组可以存储[-128, 127]的数字，因此初始化时会先去从数组中取值。

Integer a = 100;
Integer b = 100;
Integer a1 = 200;
Integer b1 = 200;
Integer a2 = new Integer(100);

a == b;     // true，从数组中取值，地址相同
a1 == b1;   // false，新创建的Integer对象，地址不同
a == a2;    // false，a2是新创建的Integer对象，地址不同

类型细节

• char类型占2字节，Java用的是Unicode
• boolean类型不能进行强制转换
• final修饰引用类型，地址不可变，值可变，final int[] num = {1, 2, 3}; num[0] = 100;
• String不可修改，想修改其中的字符可使用StringBuilder或StringBuffer

String str = "hello";
StringBuilder strBuilder = new StringBuilder(str);
strBuilder.setCharAt(1, 'a');
str = strBuilder.toString();

自动类型提升

进行算术运算时：

• 两个操作数有一个为double，计算结果提升为double
• 两个操作数没有double，有一个为float，计算结果提升为float
• 两个操作数没有float，有一个为long，计算结果提升为long
• 两个操作数没有long，有一个为int，计算结果提升为int
• 两个操作数没有int，均为short或byte，计算结果提升为int

byte,short,char—> int —> long—> float —> double

任何类型与String相加时，结果为字符串拼接，自动提升为String

控制台输入

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        
        int i = input.nextInt(); // 输入整数
        double d = input.nextDouble(); // 输入小数
        char c = input.next().charAt(0); // 输入字符
        String s = input.next(); // 输入字符串
    }
	// 如果输入了不匹配的数据，会报错java.util.InputMismatchException
}

接口

接口相当于特殊的抽象类，没有构造函数，不能创建对象，只能定义公开静态常量和公开抽象方法。

与抽象类的异同

相同

• 可编译成字节码文件
• 不能创建对象
• 可以作为引用类型
• 具备Object类中所定义的方法

不同：

• 所有属性都是公开静态常量，隐式使用public static final修饰
• 所有方法都是公开抽象方法，隐式使用public abstract修饰
• 没有构造函数，动态代码块，静态代码块

类与类只能单继承，extends 父类
类与接口能多实现，implements 接口1，接口2， 接口3
接口与接口能多继承，extends 父接口1， 父接口2， 父接口3

类

修饰符

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

访问控制和继承

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

源文件声明

• 一个源文件中只能有一个 public 类
• 一个源文件可以有多个非 public 类
• 源文件的名称应该和 public 类的类名保持一致

继承

Java 不支持多继承，但支持多重继承。

可变长字符串

• StringBuffer：运行效率慢，线程安全
• StringBuilder：运行效率快，线程不安全

运行速度比String快，占用内存比String少

集合

List实现类

• ArrayList：数组结构实现，查询快，增删慢；运行效率快，线程不安全
• Vector：数组结构实现，查询快，增删慢；运行效率慢，线程安全
• LinkedList：链表结构实现，查询慢，增删快

Set实现类

• HashSet：存储结构为哈希表（数组+链表）。基于HashCode计算元素存放位置，当存入元素哈希码相同时，调用equals()进行确认，若结果为true，则拒绝存入
• TreeSet：基于排列顺序实现元素不重复（红黑树）；实现了SortedSet接口，对集合元素进行自动排序；元素对象类型必须实现Comparable接口，指定排序规则；通过CompareTo方法，确定元素是否重复

Map

存储任意键值对
键：无序，无下标，不重复
值：无序，无下标，可重复

Map实现类

• HashMap：线程不安全，运行效率快，允许null作为key或value
• HashTable：线程安全，运行效率慢，不允许null作为key或value
• properties：HashTable的子类，要求key和value都为String，通常用于配置文件的读取
• TreeMap：实现SortedMap接口，可以对键值进行自动排序

泛型

• Java的泛型与C++的模板类似，在类名/接口名后加< T >。
• 只能用引用类型，不同类型的泛型对象不能相互赋值。
• 不能创建泛型静态常量
• 泛型方法< T >加在返回数据类型的前面，在使用方法时，不需要传递数据类型，类型由传入的参数的数据类型来传递

// 泛型类
public class MyClass <T> {
    public void show(T t) {
        System.out.println(t);
    }
}

// 泛型接口
public interface MyTnterface<T> {
    String name = "Tom";
    T print(T t);
}

public class ImplementClass implements MyTnterface<Integer> {
    public Integer print(Integer t) {
        return t;
    }
}

public class ImplementClass2<T> implements MyTnterface<T> {
    public T print(T t) {
        return t;
    }
}

// 泛型方法
public class MyClass2 {
    public <T> T show(T t) {
        System.out.println(t);
        return t;
    }
}

序列化

• 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口
• 序列化类中的对象属性要求实现Serializable接口
• 序列化版本号SerialVersionUID，保证序列化的类和反序列化的类是同一个类
• 使用transient修饰属性，这个属性不能序列化
• 静态属性不能序列化
• 序列化多个对象可以借助集合实现

序列化类

public class Employee implements java.io.Serializable {
	public transient int SSN;
	public String name;
	public String address;
	public int number;
}

序列化对象

public static void main(String [] args) {
    Employeee = new Employee();
    e.name = "Reyan Ali";
    e.address = "Phokka Kuan, Ambehta Peer";
    e.SSN = 11122333;
    e.number = 101;
    try {
        FileOutputStream fileOut = new FileOutputStream("/tmp/employee.ser");
        ObjectOutputStream out = new ObjectOutputStream(fileOut);
        out.writeObject(e);
        out.close();
        fileOut.close();
        System.out.printf("Serialized data is saved in /tmp/employee.ser");
    } catch(IOException i) {
        i.printStackTrace();
    }
}

反序列化对象

public static void main(String [] args) {
    Employee e = null;
    try {
        FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
        ObjectInputStream in = new ObjectInputStream(fileIn);
        e = (Employee) in.readObject();
        in.close();
        fileIn.close();
    } catch(IOException i) {
        i.printStackTrace();
        return;
    } catch(ClassNotFoundException c) {
        System.out.println("Employee class not found");
        c.printStackTrace();
        return;
    }
    System.out.println("Deserialized Employee...");
    System.out.println("Name: " + e.name);
    System.out.println("Address: " + e.address);
    System.out.println("SSN: " + e.SSN);  // 输出0，因为类中该属性是transient
    System.out.println("Number: " + e.number);
}