java-类型，对象，类

－　类型
byte
short
int
long
float
double

char代表采用UTF-16编码的一个字符
boolean
常量用final修饰．
－　码点与代码单元
Java字符串由char值序列组成．
char数据类型为一个采用UTF-16编码表示Unicode码点的代码单元．
常用的Unicode字符用一个代码单元即可表示，辅助字符需用一对代码单元表示．

// 对String执行length得到其对应的代码单元数量
// 执行String.codePointCount(0, String.length())得到此索引范围代码单元对应的码点数量．一个码点可认为一个Unicode字符．
// String.charAt(nIndex)得到nIndex位置的代码单元
// 得到指定码点
// int nIndex = String.offsetByCodePoints(0, i);获得指定字符的起始代码单元索引
// int cp = String.codePointAt(index);index指示的是代码单元的索引，给定代码单元索引，返回此代码单元为起始代码单元的字符的编码．
// 用int至多可存储两个UTF-16代码单元．一定可完整表达一个字符．
// Character.isSupplementaryCodePoint(int nN_)给定一个32位编码，判断若编码需２个代码单元返回true，否则，返回false．
// int[] String.codePoints().toArray()
// String(int*, int nS_, int nE_);

码点必然可存储一个Unicode字符．
代码单元对于编码长度为32位的Unicode字符无能为力．
String对象不可修改．
StringBuilder可修改

输入与输出

１．输出
System.out.println
２．输入
Scanner in = new Scanner(System.in);
String obj = in.nextLine()/nextInt()/nextDouble()
３．文件输入与输出
读取文件
Scanner in = new Scanner(Path.of("myfile.txt"), StandardCharsets.UTF_8);
写入文件
PrintWriter out = new PrintWriter("myfile.txt", StandardCharsets.UTF_8);

大数

BigInteger
BigDecimal

数组

int[] a = new int[100];
int[] smallPrimes = {2, 3, 5, 7, 11, 13};

对象与类

对象类型划分：
１．基本数据类型
２．对象引用
－　包
将类放入包中，需将包的名字放在源文件的开头

package com.horstmann.corejava;
public class Employee
{
	...
}

如没在源文件中放置package，此源文件中的类就属于无名包．
编译和运行多级目录类举例

javac com/mycompany/PayrollApp.java
java com.mycompany.PayrollApp

JAR文件使用ZIP格式组织文件和子目录，
可使用任何ZIP工具查看JAR文件．
为了使类能被多个程序共享，需做到以下：
ａ．把类文件放到一个目录中，
如/home/user/classdir
此目录是包树状结构的基目录
如增加com.Employee类，
则Employee.class类文件需位于/home/user/classdir/com
ｂ．把JAR文件放在一个目录中
如/home/user/archives
ｃ．设置类路径
/home/user/classdir:.:/home/user/archives/archive.jar
类路径含
基目录/home/user/classdir
当前目录.
JAR文件/home/user/archives/archive.jar
－　设置类路径
最好用-classpath选项指定类路径

java -classpath /home/user/classdir:.:/home/user/archives/archive.jar MyProg

JAR文件

在将应用打包时，一定希望只向用户提供一个单独的文件．
一个JAR文件既可含类文件，也可含其他类型的文件．
－　创建JAR文件
可用jar工具制作JAR文件

jar cvf jarFileName file1 file2 ...
如
jar cvf xxx.jar ...

－　清单文件
除了类文件，图形，其他资源外，
每个JAR文件还含一个清单文件，
用于描述归档文件的特殊特性，名字为MANIFEST.MF

要想编辑清单文件，需

jar cfm jarFileName manifestFileName ...

要更新一个已有的JAR文件的清单，

jar ufm MyArchive.jar manifest-additions.mf

－　可执行JAR文件

jar cvfe MyProgram.jar com.mycompany.mypkg.MainAppClass files-to-add

或在清单文件中指定程序的主类

Main-Class : com.mycompany.mypkg.MainAppClass

启动程序
java -jar MyProgram.jar
－　多版本JAR文件

文档注释

JDK有一个工具，叫javadoc
可由源文件生成一个HTML文档．
－　注释的插入
javadoc实用工具从下面几项中抽取信息
ａ．模块
ｂ．包
ｃ．公共类与接口
ｄ．公共的和受保护的字段
ｅ．公共的和受保护的构造器及方法
注释以/**开始，以*/结束．
每个/** ... */文档注释包含标记及之后紧跟着的自由格式文本．
标记以@开始．
自由格式文本的第一句应是一个概要性句子．

继承

－　Java中所有的继承都是公共继承

public class Manager extends Employee
{
	...
	// java中派生类和基类都定义了方法fun时
	// 在派生类中／针对派生类实例对象执行fun，
	// 会执行派生类的版本
	// 若要执行基类版本，
	// 需用super.fun
	
	// 构造
	public Manager(String name, double salary, int year, int month, int day)
	{
		// java没有c++的初始化列表
		super(name, salary, year, month, day);
		bonus = 0;
	}
}

Java中动态绑定是默认的行为，不需额外将函数声明为virtual．
如不希望让一个方法是虚拟的，
可将其标记为final．
－　阻止继承：final类和方法

// final类中的所有方法自动地成为final方法
public final class Executive extends Manager
{
	...
}

public class Employee
{
	...
	// final方法不可被子类覆盖
	public final String getName()
	{
		return name;
	}
	...
}

// 若将类的字段声明为final，
// 构造对象之后就不允许改变它们的值了．

－　强制类型转换

１．数值类型
double x = 3.4;
int n = (double)x;
２．基类转为派生类
if(staff[1] instanceof Manager)
{
	boss = (Manager)staff[1];
	...
}
３．无派生关系引用类型互转
产生编译错误

－　抽象类
包含一个或多个抽象方法的类本身需声明为抽象的

public abstract class Person
{
	...
	public abstract String getDescription();
}

抽象类的子类若存在部分抽象方法未具体实现，
子类也需声明为抽象类．
抽象类不能实例化，
即使类不含抽象方法，也可将类本身声明为抽象类．

－　受保护访问
１．仅对本类可见－－private
２．对外部完全可见－－public
３．对本包和所有子类可见－－protected
４．对本包可见－－默认

Object：所有类的超类

－　Object类型变量
－　equals方法

public class Employee
{
	...
	public boolean equals(Object otherObject)
	{
		if(this == otherObject)
		{
			return true;	
		}
		
		if(otherObject == null)
		{
			return false;	
		}
		
		if(getClass() != otherObject.getClass())
		{
			return false;	
		}
		
		Employee other = (Employee)otherObject;
		return name.equals(other.name) 
			&& salary == other.salary
			&& hireDay.equals(other.hireDay);
	}
}

public class Manager extends Employee
{
	...
	public boolean equals(Object otherObject)
	{
		if(!super.equals(otherObject))
		{
			return false;
		}
		
		Manager other = (Manager)otherObject;
		return bonus == other.bonus;
	}
}

－　hashCode

public class Employee
{
	public int hashCode()
	{
		// return Objects.hash(name, salary, hireDay)
		return 7 * Objects.hashCode(name)
			+ 11 * Double.hashCode(salary)
			+ 13 * Objects.hashCode(hireDay);
	}
}

对对象自定义hashCode的唯一要求，
对象a.equals(对象b)
则对象a，对象b的hashCode也应相等
－　toString方法

public class Employee
{
	public String toString()
	{
		return "Employee[name=" + name
			+ ",salary=" + salary
			+ ",hireDay=" + hireDay
			+ "]"; 
	}
	...
}

public class Manager extends Employee
{
	...
	public String toString()
	{
		return super.toString()
			+ "[bonus=" + bonus
			+ "]";	
	}
}

泛型数组列表

java.util.ArrayList<E>
ArrayList<E>()
boolean add(E obj)
int size()
E set(int index, E obj)
E get(int index)
void add(int index, E obj)
E remove(int index)

－　类型化与原始数组列表的兼容性

public class EmployeeDB
{
	public void update(ArrayList list)
	{
		...
	}
	
	public ArrayList find(String query)
	{
		...
	}
}

ArrayList之前默认模板类型为Object
现在允许ArrayList显式指定模板类型T
之前的ArrayList与现在的ArrayList<T>相互转换可能导致警告

对象包装器与自动装箱

基本类型
int
long
float
double
short
byte
char
bool
对应的包装器类
Interger
Long
Float
Double
Short
Byte
Character
Boolean
基本类型与其包装器类可隐式／显式的相互转换
基本类型转换为包装器类叫做装箱
包装器类转换为基本类型叫拆箱

隐式装箱与拆箱由编译器包装．
基本类型是Java中仅有的值类型
其余类型和包装器类型均为引用类型．

java.lang.Integer
int intValue()
static String toString(int i)
static int parseInt(String s)
static int parseInt(String s, int radix)
static Integer valueOf(String s)
static Integer valueOf(String, radix)

java.text.NumberFormat
Number parse(String s)

参数数量可变的方法

public static double max(double... values)
{
	double largest = Double.NEGATIVE_INFINITY;
	for(double v : values)
	{
		if(v > largest)
		{
			largest = v;	
		}
	}
	
	return largest;
}

枚举类

public enum Size
{
	SMALL("S"),
	MEDIUM("M"),
	LARGE("L"),
	EXTRA_LARGE("XL");
	private String abbreviation;
	private Size(String abbreviation)
	{
		this.abbreviation = abbreviation;	
	}
	
	public String getAbbreviation()
	{
		return abbreviation;
	}
};

java.lang.Enum<E>
// 返回给定类有指定名字的枚举常量
static Enum valueOf(Class enumClass, String name) 
// 返回枚举常量名
String toString()
// 返回枚举常量在enum声明中的位置，位置从０开始计数
int ordinal()
int compareTo(E other)

反射

一般用于开发工具，开发应用很少用．
－　Class类

java.lang.Class
static Class forName(String className)
Constructor getConstructor(Class... parameterTypes)

java.lang.reflect.Constructor
Object newInstance(Object... params)

java.lang.Throwable
void printStackTrace()

－　声明异常入门

public static void doSomethingWithClass(String name)
	throws ReflectiveOperationException
{
	...
}

－　资源
ａ．图像和声音文件
ｂ．包含消息字符串和按钮标签的文本文件
Class类提供了一个很有用的服务可查找资源文件，
ａ．获得拥有资源的类的Class对象
如ResourceTest.class
ｂ．有些方法接受描述资源位置的URL
URL url = cl.getResource("about.gif");
ｃ．否则，用getResourceAsStream方法
得到一个输入流来读取文件中的数据

－　利用反射分析类的能力
在java.lang.reflect包有三个类Field, Method, Constructor
分别用于描述类的字段，方法，构造器．
java.lang.reflect包的Modifier
Class类中的getFields/getMethods/getConstructors
Class类的
getDeclareFields/getDeclareMethods/getDeclaredConstructors

java.lang.Class
Field[] getFields()
Field[] getDeclaredFields()
Method[] getMethods()
Method[] getDeclaredMethods()
Constructor[] getConstructors()
Constructor[] getDeclaredConstructor()
String getPackageName()

java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Constructor
Class getDeclaringClass()
Class[] getExceptionTypes()
int getModifiers()
String getName()
Class[] getParameterTypes()
Class getReturnType()

java.lang.reflect.Modifier
static String toString(int modifiers)
static boolean isAbstract(int modifiers)
static boolean isFinal(int modifiers)
...

接口，lambda表达式与内部类

接口

public interface Comparable
{
	int compareTo(Object other);
}

// 将类声明为实现某个接口
class Employee implements Comparable
{
	public int compareTo(Object otherObject)
	{
		Employee other = (Employee)otherObject;
		return Double.compare(salary, other.salary);
	}
}

// 更好的一种风格
public interface Comparable<T>
{
	int compareTo(T other);
}

// 将类声明为实现某个接口
class Employee implements Comparable<Employee>
{
	public int compareTo(Employee other)
	{
		return Double.compare(salary, other.salary);
	}
}

接口中的所有方法都自动是public方法
接口可设置常量字段，字段总是public static final
尽管每个类只能有一个超类，但可实现多个接口

类从超类和接口类继承了名称和参数列表一致的方法时，
对类的使用者，通过类调上述方法时，采用超类版本

－　lambda表达式及式样举例

package lambda;
public class LambdaTest
{
	public static void main(String[] args)
	{
		var planets = new String[]
		{
			"Mercury",
			"Venus",
			"Earth",
			"Mars",
			"Jupiter",
			"Saturn",
			"Uranus",
			"Neptune"
		};
	
		Arrays.sort(planets);
		Arrays.sort(planets,
			(String s1, String s2)->
			{
				s1.length() - s1.length();
			});
	}
}