类型
装箱和拆箱
装箱过程就是通过包装器的 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);
}