[Java知识库]JAVA学习基础部分

Java快捷键

alt+/：智能补关键字，带提示
crtl+alt+/：智能补全关键字，不带提示
crtl+1：代码修正

JAVA主类结构

含有main()方法称为主类
文件名必须和主类的名同名
类的变量成为全局变量
方法的变量成为局部变量
主方法：public static void main(String[] args){}
导入API类库
import 。。。

基本数据类型

数值型：
整性：byte、short、int、long
浮点型：float、double
字符型、布尔型
int a=1;
float f=12.3f;
doble d=2342.12d;
char x=‘w’,只能写入单个字符；
boolean b=true

标识符

字母、下划线、美元符号、数字，第一个不能是数字、不能是保留字

保留字

int continue public this finally boolean abstract continue float long short throw for static return
break else if goto package super default byte void do
try case switch private import protected extends double implemenets char 。。。

常量

final 数据类型 常量名=值
final double p=12313.123d

变量范围

类体中定义的变量在整个类中有效
成员变量：不加static
静态变量：加上static，可以在这个应用程序中使用、跨类、以类名.静态变量的方式取值
局部变量：方法体中变量，局部变量在方法调用结束后销毁，与成员变量名字相同会覆盖

三元运算符

条件式？值1：值2；
由低到高：byte《short《int《long《float《double
低转高直接赋值：float a=12；
高转低强制：int a=(int)123.5f;

复合语句

块：{}
if条件语句
if（）{
}
if（）{
}else{
}
if（）{
}else if（）{
}else if（）{
}else{
}
switch（）{
case():
{};
case():
{};
case():
{};
deflaut:{};
}
while(){
}
do{
}while();//至少循环一次
for(int i=0;i<100;i++){
}
foreach(int x:obj){
}//x为obj中的每一个元素
break；跳出循环体，但只是一层循环体
continue；跳出本次循环

String类

String字符串类成为对象
声明：String str
char只能单个字符。
创建：char
1、String s=new String（" “）
2、Strin s=new String（a，index，length）
3、String s=” "
4、字符数组，String str[]={}

字符串格式化

日期格式化
String.format(" ",date)

正则表达式

reg="[]"

连接字符串

+，将两个字符串直接相连
不同类型与字符串相连，会被转换成字符串

获取字符串长度

str.length()

字符串查找

str.indexof(" substring")，既可以查找字符，又可以查找子字符串的第一次出现的索引
str.lastindexof(“substring”)既可以查找字符，又可以查找子字符串的最后一次出现的索引

获取指定位置的字符

str.charAt( int index)返回索引处的字符
str.substring(int beginindex）返回从开始索引位置到最后位置的子字符串
str.substring(int beginindex,int lastindex)返回从开始索引位置到制定结束索引位置的子字符串，但是不包括结束索引的字符

去除字符串前面和后面的空格

str.trim()

字符串替换

str.replace(char/string old,char/string new)原字符串重复多次出现，则会全部替换，且大小写必须保持一致

判断字符串的结尾

startwidth(String)判断是否以字符串开始
endwidth(String)判断是否以字符串结尾
返回的是布尔型

判断字符串是否相同不能用等于，因为它是判断字符串地址是否相同。

用**str1.equals（str2）比较，具有相同字符和长度时，返回true
用str1.equalsIgnoreCase(str2)**比较，忽略大小写。

按照字典顺序比较compareto()

str1.compareto(str2)，str1在str2之前返回-1，之后返回1，相同返回0

大小写转换

toLowercase()转换成小写
toUppercase()转换成大写

分割字符串

str.split(" ")以什么分割符进行分割，返回的是字符串数组；
str.splt(分割字符,分割次数)

格式化字符串

日期时间字符串格式化：String.format(" ")
。。。

频繁修改字符串

StringBuilder str=new StringBuilder("stringbuilder");
str.append("");追加内容
str.insert(5,"word");插入内容到指定索引位置
str.delete(3,5);删除内容从3开始到5结束，不包含最后一个索引
输出需要用到str.toString();

StringBuilder str=new StringBuilder()
str.append()
str.insert()
str.delete()
该类的最后要toString()

数组

先声明：
int arr[];
int arr[][];
为其分配内存空间：
arr=new int[5];
arr=new int[2][4];
声明的同时为其分配内存空间
int arr[]=new int[5];
初始化一维数组：
int arr[]=new int[]{1,2,3,4};
int arr[]={1,2,3,4};
int arr[][]={{1,2},{3,4,}};
数组元素类型[] 名字；
数组元素类型 名字[];
数组名字[]=new int[length];
int 数字名字[]=new int[];
初始化
int 数组名字[]=new int[]{1,2,3,4,5}
二维数组：
数组元素类型[][] 数组名字；
数组元素类型 数组名字[][];
数组名字=new int[][]
初始化
int 数组名字[][]=new int[][]{1,2,3,4,5}
int 数组名[][]={{},{}};
数组长度=数组.length;
数组的长度求解用arr.length;与字符串的不同,str.length();

填充替换数组

Arrays.fill(arr,对象)
Arrays.fill(arr,开始，结束，对象)

排序

Arrays.sort(obj);升序

复制数组

copyof（arr，length）复制整个数组到指定长度的数组中
copyrangeof（arr，fromindex，lastindex）不包括最后索引

数组查询

查询之前先排序；
Arrays.binarySearch（arr，obj）
Arrays.binarySearch（arr，fromindex，lastindex，obj）

三种排序算法

冒泡排序

import java.util.Arrays;
public class BubbleSort {
//	主方法
	public static void main(String[] args) {
		int array[]=new int[] {63,4,24,1,3,15};
		BubbleSort sort=new BubbleSort();//创建冒泡排序类的对象，BubbleSort类的sort对象
		sort.sort(array);//sort是sort对象的方法
		sort.showarray(array);
	}
	public void sort(int array[]) {
		for(int i=1;i<array.length;i++) {
			for(int j=0;j<array.length-i;j++) {
				if(array[j]>array[j+1]) {
					int temp;
					temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}
		
	}
	
	public void showarray(int array[]) {
		for(int i=0;i<array.length;i++) {
			System.out.println(array[i]);
		}
	}
}

直接选择排序

/**
 * 
 */

/**
 * @author ASUS
 *
 */

public class SelectSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int array[]=new int[] {63,4,24,1,3,15};
		SelectSort sort=new SelectSort();
		sort.sort(array);
		BubbleSort Bubble=new BubbleSort();
		Bubble.showarray(array);
	}
	public void sort(int array[]) {
		int index;
		for(int i=1;i<array.length;i++) {
			index=0;//每次都要从第一个元素开始对比排序
			for(int j=1;j<=array.length-i;j++) {
				if(array[j]>=array[index]) {
					index=j;
				}
				int temp=array[array.length-i];//将指定的未排序号的最后一个元素与最大值交换
				array[array.length-i]=array[index];
				array[index]=temp;
			}
		}
	}
}

反转排序

public class ReverseSort {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int array[]= {10,20,30,40,50,60};
		ReverseSort sort=new ReverseSort();
		sort.sort(array);
	}
	public void sort(int array[]) {
		int temp;
		int len=array.length;
		for(int i=0;i<len/2;i++) {
			temp=array[i];
			array[i]=array[len-i-1];
			array[len-i-1]=temp;
		}
		BubbleSort bubble=new BubbleSort();
		bubble.showarray(array);
	}

}

面向对象

对象

对象是类抽象出来的一个实例，对象符合某个类产生出来的一个实例

类

类是封装属性与方法的载体

public class Test {
    [public|private|protected][static]<void|return_type><method_name>([paramList]) {
        // 方法体
    }
}

形参是定义方法时参数列表中出现的参数，实参是调用方法时为方法传递的参数。
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在方法内部有效，方法调用结束返回主调方法后则不能再使用该形参变量。
实参和形参在数量、类型和顺序上应严格一致，否则会发生“类型不匹配” 的错误。
方法调用中发生的数据传送是单向的，即只能把实参的值传送绐形参，而不能把形参的值反向地传送给实参。因此在方法调用过程中，形参的值发生改变，而实参中的值不会变化
实参变量对形参变量的数据传递是“值传递”，即只能由实参传递给形参，而不能由形参传递给实参。程序中执行到调用成员方法时，Java 把实参值复制到一个临时的存储区（栈）中，形参的任何修改都在栈中进行，当退出该成员方法时，Java 自动清除栈中的内容

成员变量

权限修饰符（public、private、protected） 变量类型 变量名称;

成员方法

权限修饰符（public、private、protected）返回值类型 方法名（参数类型 参数名）{
方法体；
return 返回值；
}
无返回值时用void
成员方法中有与成员变量相同的局部变量，则该变量以局部变量进行

权限修饰符

private：只能在本类使用
public：本类、子类或同包其它类、其他包类
protected：本类、子类或同包其它类
deflaut：只有一个包内的其它类和子类可以对该类访问
吗

this

this关键字代表本类对象的应用，用this调用类中的成员变量和成员方法。
还可以作为方法的返回值
return this将类的对象返回；就是说这个意思：

public class testThis {
	public static void main(String[] args) {
		testThis t= new testThis();
		t.A().B();
		}
	testThis A() {
		System.out.println("A");
		return this;
	}
	void B() {
		System.out.println("B");
	}
}

t.A()返回的是testThis类的实例化对象，就是t本省，然后它才能继续执行t.B()；

构造方法

每当类实例化一个对象时，就会自动调用构造方法，构造方法无返回值，方法名称与类名称相同；不用void来修饰
例如

public book(){
成员变量赋值初始化；
}

构造函数可以有参、也可以无参，有参构造函数在创建对象时对用于有参创建构造函数，无参构造函数在创建对象时对应于无参创建构造函数。

public class Teacher {
	private String name;
	private int age;
	private double salary;//三个成员变量
public Teacher(String name,int age,double salary){
	this.name=name;
	this.age=age;
	this.salary=salary;
}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Teacher t1=new Teacher("hua",18,35000);
		System.out.println(t1.name+t1.age+t1.salary);
	}

}

public void run() {
    jump();
    System.out.println("正在执行run方法");
}
public void run() {
    // 使用this引用调用run()方法的对象
    this.jump();
    System.out.println("正在执行run方法");
}

一个类中的方法调用该类中的其它方法可以使用this.方法(),也可以直接方法()；
this还可以调用构造函数。只有this的时候才可以
this( ) 不能在普通方法中使用，只能写在构造方法中。
在构造方法中使用时，必须是第一条语句。

public class AnyThing {
public static void main(String[] args) {
	AnyThing test=new AnyThing();
}
public AnyThing() {
	this("WO YI DING XING");
	System.out.println("wucan");
}
public AnyThing(String str) {
	System.out.println(str);
}
}

静态变量、常量、方法

static，可以被本类或者其它类调用，用类名.静态类成员；指的是可以共享同一个数据，不用再单独创建。
静态方法不可使用this，静态方法不可直接调用非静态方法
方法体中的局部变量也不能声明为static

类的主方法

public static void main(String[] args){
}
主方法是静态的，因此直接调用类中的其它方法必须也是静态的static；主方法无返回值；
args是程序的参数，可以使用args,length；

对象

创建

无参对象创建：类名 对象名=new 类名()；自动调用无参构造函数
有参对象创建：类名 对象名=new 类名("参数")；自动调用有参构造函数

访问对象的属性与行为

对象.类成员
调用非静态成员变量

public class TransferProperty {
	int i=47;
	public void call() {
		System.out.println("调用call（）方法");
		for(int i=0;i<3;i++) {
			System.out.println(i);
			if(i==2) {
				System.out.println("\n");
			}
		}
	}
	public TransferProperty() {	
	}
//main 
public static void main(String[] args) {
	TransferProperty t1=new TransferProperty();
	TransferProperty t2=new TransferProperty();
	t2.i=60;
	System.out.println("第一个实例对象调用t1:"+t1.i++);
	t1.call();
	System.out.println("第二个实例对象调用t2:"+t2.i);
	t2.call();
}
}

调用成员变量，不同对象调用相同的成员变量之间是相互独立的，因为它们指向了不同的内存空间。
调用静态成员变量

public class TransferProperty {
	 static int i=47;
	public void call() {
		System.out.println("调用call（）方法");
		for(int i=0;i<3;i++) {
			System.out.println(i);
			if(i==2) {
				System.out.println("\n");
			}
		}
	}
	public TransferProperty() {	
	}
//main 
public static void main(String[] args) {
	TransferProperty t1=new TransferProperty();
	TransferProperty t2=new TransferProperty();
	t2.i=60;
	System.out.println("第一个实例对象调用t1:"+ t1.i++);
	t1.call();
	System.out.println("第二个实例对象调用t2:"+t2.i);
	t2.call();
}
}

指向了相同的内存空间，因此静态成员变量的值会改变。
java.lang.Class Class 类对象名称 = java.lang.Class.forName(要实例化的类全称);
类名 对象名 = (类名)Class类对象名称.newInstance();
调用 java.lang.Class 类中的 forName() 方法时，需要将要实例化的类的全称（比如 com.mxl.package.Student）作为参数传递过去，然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。
 Class c1 = Class.forName("Student");
        Student student2 = (Student)c1.newInstance();
        使用 Class 类的 newInstance() 方法创建对象时，会调用类的默认构造方法，即无参构造方法。

类名对象名 = (类名)已创建好的类对象名.clone();
 // 调用对象的 clone() 方法创建对象
        Student student3 = (Student)student2.clone();
        使用 Object 类的 clone() 方法创建对象时，不会调用类的构造方法，它会创建一个复制的对象，这个对象和原来的对象具有不同的内存地址，但它们的属性值相同。

匿名对象

如果一个对象只需要使用唯一的一次，就可以使用匿名对象，匿名对象还可以作为实际参数传递。

匿名对象就是没有明确的给出名字的对象，是对象的一种简写形式。一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

 new Person("张三", 30)

没有任何栈内存引用它，所以此对象使用一次之后就等待被 GC（垃圾收集机制）回收
因此创建对象可以直接使用new 类名称();

对象的引用

类名 对象名;引用只是存放对象的内存地址，并非存放一个对象，
new 类名()；是创建对象，类名 对象名是引用。

对象的比较

==比较地址是否相同
equals()比较内容是否相同

对象的销毁

垃圾回收机制：对象引用超出作用范围；对象赋值为null

实例

import java.util.Scanner;
public class MemberTest {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Member admin=new Member("admin","123456");
		Scanner input=new Scanner(System.in);
		System.out.println("请输入原密码：");
		String pwd=input.next();
		if(pwd.equals(admin.getUsername())) {
			System.out.println("请输入新密码：");
			admin.setPassword(input.next());
		}else {
			System.out.println("输入密码错误，无法进行修改");
		}
		/*直接打印对象，看似没有调用toString(),实质上默认自动调用toString()
		 *与 admin.toString()效果一致*/
		System.out.println("用户信息\n"+admin);
	}
}
执行System.out.println(obj);与System.out.println(obj.toString());方法的结果是一样的。

public class Member {
private String username;
private String password;
public String getUsername() {
	return this.username;
}
public void setUsername(String username) {
	this.username=username;
}
public String getPassword() {
	return this.password;
}
public void setPassword(String password) {
	this.password=password;
}
public Member(String username,String password) {
	this.username=username;
	this.password=password;
}
public String toString() {
	return "用户名："+this.username+"\n密码："+this.password;
}
}

类注释

类注释
类注释一般必须放在所有的“import”语句之后，类定义之前，主要声明该类可以做什么，以及创建者、创建日期、版本和包名等一些信息。以下是一个类注释的模板。

/**
 * @projectName（项目名称）: project_name
 * @package（包）: package_name.file_name
 * @className（类名称）: type_name
 * @description（类描述）: 一句话描述该类的功能
 * @author（创建人）: user 
 * @createDate（创建时间）: datetime  
 * @updateUser（修改人）: user 
 * @updateDate（修改时间）: datetime
 * @updateRemark（修改备注）: 说明本次修改内容
 * @version（版本）: v1.0
 */

方法注释

2. 方法注释
   方法注释必须紧靠在方法定义的前面，主要声明方法参数、返回值、异常等信息。除了可以使用通用标签外，还可以使用下列的以@开始的标签。
   @param 变量描述：对当前方法的参数部分添加一个说明，可以占据多行。一个方法的所有 @param 标记必须放在一起。
   @return 返回类型描述：对当前方法添加返回值部分，可以跨越多行。
   @throws 异常类描述：表示这个方法有可能抛出异常。

/**
 * @param num1: 加数1
 * @param num2: 加数2
 * @return: 两个加数的和
 */
public int add(int num1,int num2) {
    int value = num1 + num2;
    return value;
}

3. 字段注释
   字段注释在定义字段的前面，用来描述字段的含义。下面是一个字段注释的例子。
   纯文本复制
   /**

• 用户名
  */
  public String name;

访问范围

private friendly(默认) protected public
同一个类 可访问 可访问 可访问 可访问
同一包中的其他类 不可访问 可访问 可访问 可访问
不同包中的子类 不可访问 不可访问 可访问 可访问
不同包中的非子类 不可访问 不可访问 不可访问 可访问

静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。
如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
在访问非静态方法时，需要通过实例对象来访问，而在访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问
静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。
如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI。

包装

把这些包装都看作是类，所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
包装类 基本数据类型
Boolean boolean
Byte byte
Short short
Integer int
Long long
Character char
Float float
Double double

Integer类

构造方法

两种带参数的构造方法：
Integer number=new Integer（123）；
Integer number=new Integer（“123”）； 这种方法在jdk1.9已不再支持
现在以Integer.ValueOf(" ")为准，

Integer.toString(int par1,int par2),par1表示要转成字符串的数字，par2表示要转成的进制表示
比较返回的整型数值
obj.compareTo(obj2);
str.compareTo(str2);
Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。
Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。
Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

String

x.toString();
Integer.toString(12)
x.compareTo(3);如果指定的数与参数相等返回0。;如果指定的数小于参数返回 -1。如果指定的数大于参数返回 1。
x.equals(Object o)返回值True、False
round() 方法返回一个最接近的 int、long 型值，四舍五,Math.round(数值)

类型	方法及描述
byte	
byteValue() :
以 byte 形式返回指定的数值。
abstract double	
doubleValue() :
以 double 形式返回指定的数值。
abstract float	
floatValue() :
以 float 形式返回指定的数值。
abstract int	
intValue() :
以 int 形式返回指定的数值。
abstract long	
longValue() :
以 long 形式返回指定的数值。
short	
shortValue() :

连接字符串
String 类提供了连接两个字符串的方法：
string1.concat(string2);

以 short 形式返回指定的数值。
Math.min(a,b)
Math.max(a,b)
格式化字符串
system.out.printf()、String.format()

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

StringBuffer

序号	方法描述
1	public StringBuffer append(String s)
将指定的字符串追加到此字符序列。
2	public StringBuffer reverse()
 将此字符序列用其反转形式取代。
3	public delete(int start, int end)
移除此序列的子字符串中的字符。
4	public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。
5	insert(int offset, String str)
将 str 参数的字符串插入此序列中。
6	replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。

StringBuffer对象.方法（append（）、insert（）、delete（）、replace（）、reverse（））

Character

\t	在文中该处插入一个tab键
\b	在文中该处插入一个后退键
\n	在文中该处换行
\r	在文中该处插入回车
\f	在文中该处插入换页符
\'	在文中该处插入单引号
\"	在文中该处插入双引号
\\	在文中该处插入反斜杠

Character.isUpperCase('c')要测试字符是不是c的大写字母
Character.toUpperCase('a')要转换的字符

char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A'; 
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

random类

Math.random()会产生一个0-1的随机double数；
实例化random类
Random number=new Random()
封装的方法
number.nextInt(n)随机产生整数0-n；
随机生成整数：

public class MathRandom {
//
	/*
	 * num1是最小值 num2是最大值
	 */
	/**
	 * 
	 * @param num1起始值
	 * @param num2终止值
	 * @return返回值为随机数
	 */
//	文档注释为/**+enter
//多行注释为ctrl+shift+/
public static int GetNum(double num1,double num2) {
	int s=(int)num1+(int)(Math.random()*(num2-num1));//强制类型转换是（int）带上括号，
	return s;
	/*
	 * if(s%2==0) { return s; } else { return s+1; }随机偶数
	 */
}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println(GetNum(2,32));//静态方法可以直接调用
	}

}

随机生成字符:
注意字符与int类型之间的转换关系

public class RandomChar {
public static char GetChar(char a, char b) {
	return (char)(a+(Math.random()*(b-a+1)));
}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
System.out.println(GetChar('a','g'));
	}

}

方法

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法的重载

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。一旦你定义了自己的构造方法，默认构造方法就会失效。

class MyClass {
  int x;
  // 以下是构造函数
  MyClass() {
    x = 10;
  }
}

main

使用 main() 方法时应该注意如下几点：
1、访问控制权限是公有的（public）。
2、main() 方法是静态的。如果要在 main() 方法中调用本类中的其他方法，则该方法也必须是静态的，否则需要先创建本类的实例对象，然后再通过对象调用成员方法。
3、main() 方法没有返回值，只能使用 void。
4、main() 方法具有一个字符串数组参数，用来接收执行 Java 程序的命令行参数。命令行参数作为字符串，按照顺序依次对应字符串数组中的元素。
5、字符串中数组的名字（代码中的 args）可以任意设置，但是根据习惯，这个字符串数组的名字一般和 Java 规范范例中 main() 参数名保持一致，命名为 args，而方法中的其他内容都是固定不变的。
6、main() 方法定义必须是“public static void main(String[] 字符串数组参数名)”。
7、一个类只能有一个 main() 方法，这是一个常用于对类进行单元测试（对软件中的最小可测试单元进行检查和验证）的技巧。

可变参数

声明可变参数的语法格式如下：
methodName({paramList},paramType…paramName)
其中，methodName 表示方法名称；paramList 表示方法的固定参数列表；paramType 表示可变参数的类型；… 是声明可变参数的标识；paramName 表示可变参数名称。可变参数必须定义在参数列表的最后。

 public void print(String...names) {
        int count = names.length;    // 获取总个数

Java 构造方法有以下特点：
1、方法名必须与类名相同
3、可以有 0 个、1 个或多个参数
4、没有任何返回值，包括 void
5、默认返回类型就是对象类型本身
6、只能与 new 运算符结合使用

析构方法

protected void finalize() {
    // 对象的清理工作
}

封装

封装性：类将内部数据隐藏，为用户提供对象的属性与行为的接口
实现封装的具体步骤如下：
修改属性的可见性来限制对属性的访问，一般设为 private。
为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）
使用get访问值和set赋值

public class Employee {
    private String name; // 姓名
    private int age; // 年龄
    private String phone; // 联系电话
    private String address; // 家庭住址

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        // 对年龄进行限制
        if (age < 18 || age > 40) {
            System.out.println("年龄必须在18到40之间！");
            this.age = 20; // 默认年龄
        } else {
            this.age = age;
        }
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

public class EmployeeTest {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Employee people=new Employee();
		people.setName("王丽丽");
		people.setAddress("河北石家庄");
		people.setAge(21);
		people.setPhone("12314141251");
		System.out.println("姓名："+people.getName());
		System.out.println("年龄："+people.getAge());
		System.out.println("地址："+people.getAddress());
		System.out.println("电话："+people.getPhone());
	}

}

继承

两个类之间的关系，子类继承父类一些属性与行为，也可以增加父类不具备的属性与行为，或者直接重写父类的某些方法。
extends表示继承
权限修饰符 返回值类型 方法名（参数类型 参数名称）{
}
类名作为返回值类型
一个方法的返回值类型是一个类名，就返回该类的一个对象

1. 既可以在子类中使用super()调用父类的构造方法，也可以在子类中使用super.方法调用父类成员方法
2. 但是没有权限调用private的方法，只可以调用父类中public、protected
3. 还可以在子类中定义一些新方法

Java 中子类继承父类的语法格式如下：
修饰符 class class_name extends extend_class {
// 类的主体
}
其中，class_name 表示子类（派生类）的名称；extend_class 表示父类（基类）的名称；extends 关键字直接跟在子类名之后，其后面是该类要继承的父类名称。例如：
public class Student extends Person{}

重写

将父类的方法名保留，重写方法的内容、修饰权限、返回值类型。

重构

唯一不同的是方法的实现内容不同。

修饰权限

重写方法时，修饰权限只能从小到大，即不能降低方法的修饰范围。
如，父类方法是protected，子类修饰修改的话只能为public

返回值类型

重写的返回值类型必须是父类中同一方法返回值类型的子类，即
Test2是Test（父类）的子类
实例化子对象时，父类对象也将实例化，即自动调用父类的无参构造方法，并且先从顶级父类开始实例化对象，再次是上一级父类，最后是子类，并且只能是无参的构造函数，有参数的构造函数必须通过super显示的调用

Object

Object是所有类的父类，省略了extends Object，任何类都可以重写其方法。如：clone()、finalize（）、equals（）、toString（）、
final类型的方法不能重写，例如getClass（）、notify（）、notifyAll()、wait（）
1、getClass()返回对象执行的Class实例；通过getName()取得类的名称；
2、toString()将对象返回为字符串形式，
3、equals比较内容相同，但是比较不同的实例化对象时，返回false

向上转型

父类引用指向子类对象为向上转型，语法格式如下：

fatherClass obj = new sonClass();

其中，fatherClass 是父类名称或接口名称，obj 是创建的对象，sonClass 是子类名称。
子类对象看作父类对象称为向上转型
父类名称 父类对象 =new 子类名称（）；

public class People {

public String name;
public int age;
public String sex;
public String sn;
public People(String name,int age,String sex,String sn) {
	this.name=name;
	this.age=age;
	this.sex=sex;
	this.sn=sn;	
}
public String toString() {
	return "姓名："+name+"\n年龄："+age+"\n性别："+sex+"\n身份证："+sn;
}
}
class Student extends People{
	private String stuNo;
	private String department;
	/*如果在父类中存在有参的构造方法而并没有重载无参的构造方法，
	 * 那么在子类中必须含有有参的构造方法，
	 * 因为如果在子类中不含有构造方法，
	 * 默认会调用父类中无参的构造方法，而在父类中并没有无参的构造方法，因此会出错。*/
	public Student(String name,int age,String sex,String sn,String stuNo,String department) {
		super(name,age,sex,sn);//有参构造函数
		this.department=department;
		this.stuNo=stuNo;
	}
	/*在 Student 类中同样具有 People 类的属性和方法，这里重写了父类中的 toString() 方法。*/
	public String toString() {
		return "姓名："+name+"\n年龄："+age+"\n性别："+sex+"\n身份证："+sn+"\n学号："+stuNo+"\n专业："+department;
	}
}
class Teachers extends People{
private int tYear;
private String tDept;
	public Teachers(String name, int age, String sex, String sn,int tYear,String tDept) {
		super(name, age, sex, sn);
		this.tYear=tYear;
		this.tDept=tDept;
	}
	public String toString() {
		return "姓名："+name+"\n年龄："+age+"\n性别："+sex+"\n身份证："+sn+"\n教龄："+tYear+"\n所教专业："+tDept;
	}
}
class  PeopleTest{
	public static void main(String[] args) {
		//Student可以换成People
		Student p=new Student("王丽",23,"女","12312412541","123124","计算机应用");
		System.out.println(p);
		//Teachers可以换成People
		Teachers p1=new Teachers("张总",23,"女","12312412541",5,"计算机应用");
		System.out.println(p1);
	}
}

super

super 关键字的功能：
在子类的构造方法中显式的调用父类构造方法
访问父类的成员方法和变量。
调用父类的无参构造方法，必须写在子类构造方法的第一句

super 关键字可以在子类的构造方法中显式地调用父类的构造方法，基本格式如下：
super(parameter-list);

使用 super 访问父类中的成员与 this 关键字的使用相似，只不过它引用的是子类的父类：super.member

super与this区别

this 指的是当前对象的引用，super 是当前对象的父对象的引用

super 关键字的用法：
super.父类属性名：调用父类中的属性
super.父类方法名：调用父类中的方法
super()：调用父类的无参构造方法
super(参数)：调用父类的有参构造方法
如果构造方法的第一行代码不是 this() 和 super()，则系统会默认添加 super()。
this 关键字的用法：
this.属性名：表示当前对象的属性
this.方法名(参数)：表示调用当前对象的方法

向下转型

将父类对象强制转换成子类对象，
子类名称 子类对象名称=（子类名称）父类对象名称；
与向上转型相反，子类对象指向父类引用为向下转型，语法格式如下：

sonClass obj = (sonClass) fatherClass;

其中，fatherClass 是父类名称，obj 是创建的对象，sonClass 是子类名称。

强制类型转换

((Cat)animal).str = "";    // 编译成功
((Cat)animal).eatMethod();    // 编译成功

instanceof判断对象类型

myobject instanceof exampleClass
判断一个实例对象myobject是否属于一个类exampleClass，属于返回true，不属于返回false。
通常判断父类对象是否为子类对象的实例
1）声明一个 class 类的对象，判断 obj 是否为 class 类的实例对象（很普遍的一种用法），如以下代码：
Integer integer = new Integer(1);
System.out.println(integer instanceof Integer); // true

public class Parellelogram  extends Qua{
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Qua q=new Qua();
		if(q instanceof Parellelogram) {
			Parellelogram p=(Parellelogram) q;//向下强制转换
		}
		if(q instanceof squ) {
			squ s=(squ) q;//向下强制转换
		}
	}
}
class Qua{
	public static void draw(Qua q) {
	}
}
class squ extends Qua{
}
class anything1{
}

重载

方法重载的要求是两同一不同：同一个类中方法名相同，参数列表不同，如方法返回值类型、修饰符等，与方法重载没有任何关系。
在同一个类中允许同时存在一个以上的同名方法，只要这些方法的参数个数或者参数类型不同。

public class OverLoadTest {

	public static int add(int a,int b) {
		return a+b;
	}
	public static double add(double a, double b) {
		return a+b;
	}
	public static int add(int a) {
		return a;
	}
	public static int add(int a,double b) {
		return 1;
	}
	public static int add(double a, int b) {
		return 1;
	}
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println(add(1,2));
		System.out.println(add(2.1,3.3));
		System.out.println(add(1));
		System.out.println(add(2.1,3));
	}
}

参数类型、个数、顺序不同都可以构成重载

不定长参数重载

实质上是传入了一个数组，用参数类型… 参数名称

public class OverLoadTest2 {
	public static int add(int a,int b) {
		return a+b;
	}
	public static double add(double a, double b) {
		return a+b;
	}
	public static int add(int a) {
		return a;
	}
	public static int add(int a,double b) {
		return 1;
	}
	public static int add(double a, int b) {
		return 1;
	}
	/*
	 * 不定长参数重载
	*/
	public static int add(int...a) {
		int sum=0;
		for(int i=0;i<a.length;i++) {
			sum+=a[i];
		}
		return sum;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println(add(2));
		System.out.println(add(1,2,3,4,5,6,7,8,9));
	}
}

多态

继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。
父类对象应用于子类特征，利用多态可以使得程序具有拓展性，对所有类的对象具有通用处理。
不能对非静态字段 进行静态引用

class Square extends Quadrangle{
	public  Square() {
		System.out.println("正方形");
	}
	
}
class Parellelogramgle extends Quadrangle{
	public Parellelogramgle() {//构造函数不会返回值，因此也就没有返回值类型
		System.out.println("长方形");
	}
}
public class Quadrangle {
	private Quadrangle qtest[]=new Quadrangle[6];//成员变量，修饰为private 实例化数组对象
	private int nextindex=0;//私有的成员变量
//	Quadrangle q为该类的对象
	public  void draw(Quadrangle q) {//公共的成员方法
		if(nextindex<qtest.length) {
			qtest[nextindex]=q;
			System.out.println(nextindex);
			nextindex++;
		}
	}

	/*不同类对象为参数调用draw()方法，可以处理不同图形问题
	 * 只要实例化一个继承父类的子类对象集合调用相应的方法*/
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Quadrangle q=new Quadrangle();//本类对象实例化
		q.draw(new Square());//正方形对象为参数调用draw();
		q.draw(new Parellelogramgle());//长方形对象为参数调用draw();
	}
}

无论 figure 变量的对象是 Rectangle 还是 Triangle，它们都是 Figure 类的子类，因此可以向上转型为该类，从而实现多态

public class Figure {
double dim1;
double dim2;
Figure(double d1,double d2){
	this.dim1=d1;
	this.dim2=d2;
}
double area() {
	System.out.println("父类中计算对象面积的方法，没有实际意义，需要在子类中重写。");
	return 0;
}
}
class Rectangle extends Figure{
	Rectangle(double d1,double d2){
		super(d1,d2);
	}
	double area() {
		System.out.println("长方形的面积");
		return super.dim1*super.dim2;
		
	}
}
class Triangle extends  Figure{
	Triangle(double d1,double d2){
		super(d1, d2);
	}
	double area() {
		System.out.println("三角形的面积");
		return super.dim1*super.dim2/2;
	}
}
class Test{
	public static void main(String[] args) {
		Figure figure;//声明figure类型变量
		//向上转型
		/*在该类的 main() 方法中首先声明 Figure 类的变量 figure，
		 * 然后分别为 figure 变量指定不同的对象，
		 * 并调用这些对象的 area() 方法*/
		figure=new Rectangle(9,9);
		System.out.println(figure.area());
		figure=new Triangle(6,8);
		System.out.println(figure.area());
		figure=new Figure(10,10);
		System.out.println(figure.area());
	}
}

抽象类

public abstract class Test{
abstract void test()；定义抽象方法
}

承载抽象方法的抽象类必须被继承，否则无任何意义，声明一个抽象方法，必须将承载这个抽象方法的类定义为抽象类。
抽象类的所有子类必须将抽象类的中抽象方法进行覆盖，即：
父类：abstract void test()
子类：void test()

抽象方法没有方法体

在 Java 中抽象类的语法格式如下：

<abstract>class<class_name> {
    <abstract><type><method_name>(parameter-iist);
}

其中，abstract 表示该类或该方法是抽象的；class_name 表示抽象类的名称；method_name 表示抽象方法名称，parameter-list 表示方法参数列表。

如果一个方法使用 abstract 来修饰，则说明该方法是抽象方法，抽象方法只有声明没有实现。需要注意的是 abstract
关键字只能用于普通方法，不能用于 static 方法或者构造方法中。
抽象方法的 3 个特征如下： 抽象方法没有方法体 抽象方法必须存在于抽象类中 子类重写父类时，必须重写父类所有的抽象方法

接口

[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
    // 接口体，其中可以包含定义常量和声明方法
    [public] [static] [final] type constant_name = value;    // 定义常量
    [public] [abstract] returnType method_name(parameter_list);    // 声明方法
}

具有 public 访问控制符的接口，允许任何类使用；没有指定 public 的接口，其访问将局限于所属的包。
方法的声明不需要其他修饰符，在接口中声明的方法，将隐式地声明为公有的（public）和抽象的（abstract）。
在 Java 接口中声明的变量其实都是常量，接口中的变量声明，将隐式地声明为 public、static 和 final，即常量，所以接口中定义的变量必须初始化。
接口没有构造方法，不能被实例化

public interface drawTest{
void draw();接口内的方法
}
权限修饰符 interface接口关键字 接口名称{
}

在接口中定义的方法必须被定义为public或者是abstract。
接口中的任何字段都自动是static和final

实现接口

实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间以逗号分隔。
一个类可以继承一个父类，并同时实现多个接口，implements 部分必须放在 extends 部分之后。
一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] {
    // 主体
}

接口与类相似点：

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

使用interface这个关键字，在接口中的所有方法都必须只声明方法标识，而不要去声明具体的方法体，因为具体的方法体的实现是由继承该接口的类来去实现的，因此，接口并不用管具体的实现。接口中的属性默认为Public Static Final.一个类实现这个接口必须实现这个接口中定义的所有的抽象方法。

一个简单的接口就像这样：拥有全局变量和抽象方法。

使用implements关键词去实现接口：


先声明USB接口：其中规定了要实现USB接口就必须实现接口规定实现的read( )和write( )这两个方法。
定义一个接口

interface USB {
    void read();

    void write();
}

写两种类去实现这个接口

class YouPan implements USB {
    @Override
    public void read() {
        System.out.println("U盘正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("U盘正在通过USB功能写入数据");
    }
}
class JianPan implements USB {
    @Override
    public void read() {
        System.out.println("键盘正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("键盘正在通过USB功能写入数据");
    }
}

public class Main {
    public static void main(String[] args) {
        //生成一个实现可USB接口（标准）的U盘对象
        YouPan youPan = new YouPan();
        //调用U盘的read( )方法读取数据
        youPan.read();
        //调用U盘的write( )方法写入数据
        youPan.write();
        //生成一个实现可USB接口（标准）的键盘对象
        JianPan jianPan = new JianPan();
        //调用键盘的read( )方法读取数据
        jianPan.read();
        //调用键盘的write( )方法写入数据
        jianPan.write();
    }
}

重写

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。
1、参数列表必须完全与被重写的方法参数列表相同。
2、返回的类型必须与被重写的方法的返回类型相同
3、访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
4、重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。

重写的方法可以使用 @Override 注解来标识。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够再次声明。
构造方法不能被重写。
子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
如果不能继承一个方法，则不能重写这个方法。

使用接口类型的引用指向一个实现了该接口的对象，并且可以调用这个接口中的方法

这是接口的核心意义。上面的实现接口还可以这样写：

public class Main {
    public static void main(String[] args) {
        //生成一个实现可USB接口（标准）的U盘对象
        //但是使用一个接口引用指向对象
        //USB接口类引用可以指向一个实现了USB接口的对象
        USB youPan = new YouPan();
        //调用U盘的read( )方法读取数据
        youPan.read();
        //调用U盘的write( )方法写入数据
        youPan.write();
        //生成一个实现可USB接口（标准）的键盘对象
        //但是使用一个接口引用指向对象
        //USB接口类引用可以指向一个实现了USB接口的对象
        USB jianPan = new JianPan();
        //调用键盘的read( )方法读取数据
        jianPan.read();
        //调用键盘的write( )方法写入数据
        jianPan.write();
    }
}                                       

new YouPan()是要实现接口的对象，这个对象指向USB接口类引用
new JianPan()是要实现接口的对象，这个对象指向USB接口类引用
在Java中，类的多继承是不合法，但接口允许多继承。
在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。 如下所示：
public interface Hockey extends Sports, Event

包

package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句

package 包名;

Java 包的命名规则如下：
包名全部由小写字母（多个单词也全部小写）。
如果包名包含多个层次，每个层次用“.”分割。
包名一般由倒置的域名开头，比如 com.baidu，不要有 www。
自定义包不能 java 开头。
包的作用
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

package pkg1[．pkg2[．pkg3…]];
例如
package net.java.util;
net/java/util/Something.java
包名称.类名称

import package1[.package2…].(classname|*);
用 import 关键字引入，使用通配符 *：

import payroll.*;
使用 import 关键字引入 Employee 类：

import payroll.Employee;

内部类

在类 A 中定义类 B，那么类 B 就是内部类，也称为嵌套类，相对而言，类 A 就是外部类。如果有多层嵌套，例如类 A 中有内部类 B，而类 B 中还有内部类 C，那么通常将最外层的类称为顶层类（或者顶级类）。
内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。
内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。
外部类只有两种访问级别：public 和默认；内部类则有 4 种访问级别：public、protected、 private 和默认。

package com.dao;
//public 和默认
public class Test {
//	外部类直接通过内部类的类名访问内部类
	InnerClass ic = new InnerClass(); 
//	public、protected、 private 和默认。
public class InnerClass{
	public int getSum(int x,int y) {
		return x+y;
	}
}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
	
Test.InnerClass ti=new Test().new InnerClass();
int i=ti.getSum(2, 5);
System.out.println(i);
	}
}

public class Outer {
    int a = 10;

    class Inner {
        int a = 20;
        int b1 = a;
        int b2 = this.a;
        int b3 = Outer.this.a;
    }

    public static void main(String[] args) {
        Inner i = new Outer().new Inner();
        System.out.println(i.b1); // 输出20
        System.out.println(i.b2); // 输出20
        System.out.println(i.b3); // 输出10
    }
}

创建静态内部类实例

1）在创建静态内部类的实例时，不需要创建外部类的实例。
纯文本复制
public class Outer {
    static class Inner {
    }
}
class OtherClass {
    Outer.Inner oi = new Outer.Inner();
}

访问静态内部类的成员

2）静态内部类中可以定义静态成员和实例成员。外部类以外的其他类需要通过完整的类名访问静态内部类中的静态成员，如果要访问静态内部类中的实例成员，则需要通过静态内部类的实例。
纯文本复制
public class Outer {
    static class Inner {
        int a = 0;    // 实例变量a
        static int b = 0;    // 静态变量 b
    }
}
class OtherClass {
    Outer.Inner oi = new Outer.Inner();
    int a2 = oi.a;    // 访问实例成员
    int b2 = Outer.Inner.b;    // 访问静态成员
}

访问外部类的成员

静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员，则需要通过外部类的实例去访问。
纯文本复制
public class Outer {
    int a = 0;    // 实例变量
    static int b = 0;    // 静态变量
    static class Inner {
        Outer o = new Outer;
        int a2 = o.a;    // 访问实例变量
        int b2 = b;    // 访问静态变量
    }
}

局部内部类

局部内部类是指在一个方法中定义的内部类。示例代码如下：
public class Test {
public void method() {
class Inner {
// 局部内部类
}
}
}
局部内部类有如下特点：
1）局部内部类与局部变量一样，不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰。
2）局部内部类只在当前方法中有效。
public class Test {
Inner i = new Inner(); // 编译出错
Test.Inner ti = new Test.Inner(); // 编译出错
Test.Inner ti2 = new Test().new Inner(); // 编译出错
public void method() {
class Inner{

    }
    Inner i = new Inner();
}

}
3）局部内部类中不能定义 static 成员。、
4）局部内部类中还可以包含内部类，但是这些内部类也不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰。
5）在局部内部类中可以访问外部类的所有成员。

匿名类

匿名类是指没有类名的内部类，必须在创建时使用 new 语句来声明类。其语法形式如下：
纯文本复制
new <类或接口>() {
// 类的主体
};
继承一个类，重写其方法。
实现一个接口（可以是多个），实现其方法。

Effectively final

一个非 final 的局部变量或方法参数，其值在初始化后就从未更改，那么该变量就是 effectively final。
Lambda 表达式：把函数作为一个方法的参数（函数作为参数传递进方法中）
printf 主要继承了C语言中 printf 的一些特性，可以进行格式化输出。
print 就是一般的标准输出，但是不换行。
println 和 print 基本没什么差别，就是最后会换行。

Lambda 表达式标准语法形式如下：
(参数列表) -> {
    // Lambda表达式体
}

->被称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分：
左侧：Lambda 表达式的参数列表。
右侧：Lambda 表达式中所需执行的功能，用{ }包起来，即 Lambda 体。

package com.lzw;
public class Test {
    /**
     * 通过操作符，进行计算
     *
     * @param opr 操作符
     * @return 实现Calculable接口对象
     */
	public static Calculable cal(char opr) {
		Calculable res;
		if(opr=='+') {

 // Lambda表达式实现Calculable接口
			res=(int a,int b)-> {
					return a+b;
			};
		}else {
//			匿名函数实现接口
		/*	new 类名/接口{
				类体；
			}*/
			res=new Calculable() {
				@Override
			public 	int calculate(int a,int b) {
					return a-b;
				}
			};
		}
		return res;//返回值是实现 Calculable 接口对象
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
int n1=10;
int n2=5;
Calculable f1=cal('+');
Calculable f2=cal('-');
System.out.println(f1.calculate(n1,n2));
System.out.println(f2.calculate(n1,n2));
	}
}

Lambada表达式只能有一个抽象方法的接口，@FunctionalInterface。该注解可用于一个接口的定义上，一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错

package com.lzw;
@FunctionalInterface
public interface Calculable {
int calculate(int a,int b) ;
}

内部类this.成员直接调用内部类成员，外部类.this.成员调用外部类成员

异常

异常（exception）是在运行程序时产生的一种异常情况
在 Java 中一个异常的产生，主要有如下三种原因：
1、Java 内部错误发生异常，Java 虚拟机产生的异常。
2、编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。
3、通过 throw 语句手动生成的异常，一般用来告知该方法的调用者一些必要信息。
把生成异常对象，并把它提交给运行时系统的过程称为拋出（throw）异常。运行时系统在方法的调用栈中查找，直到找到能够处理该类型异常的对象，这一个过程称为捕获（catch）异常

在 Java 中所有异常类型都是内置类java.lang.Throwable 类的子类，即 Throwable
位于异常类层次结构的顶层。Throwable 类下有两个异常分支 Exception 和 Error
Exception 类用于用户程序可能出现的异常情况，它也是用来创建自定义异常类型类的类。
Error 定义了在通常环境下不希望被程序捕获的异常。一般指的是 JVM 错误，如堆栈溢出。

运行时异常都是 RuntimeException 类及其子类异常，如 NullPointerException、IndexOutOfBoundsException 等，由程序逻辑错误引起。
非运行时异常是指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如 IOException、ClassNotFoundException 等以及用户自定义的 Exception 异常。
运行时异常

非运行时异常
1）运行时异常（RuntimeException）：
NullPropagation：空指针异常；
ClassCastException：类型强制转换异常
IllegalArgumentException：传递非法参数异常
IndexOutOfBoundsException：下标越界异常
NumberFormatException：数字格式异常
2）非运行时异常：
ClassNotFoundException：找不到指定 class 的异常
IOException：IO 操作异常
3）错误（Error）：
NoClassDefFoundError：找不到 class 定义异常
StackOverflowError：深递归导致栈被耗尽而抛出的异常
OutOfMemoryError：内存溢出异常

异常处理

try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。
在方法中用 try catch 语句捕获并处理异常，catch 语句可以有多个，用来匹配多个异常。
对于处理不了的异常或者要转型的异常，在方法的声明处通过 throws 语句拋出异常，即由上层的调用方法来处理。
基本结构

try {
    逻辑程序块
} catch(ExceptionType1 e) {
    处理代码块1
} catch (ExceptionType2 e) {
    处理代码块2
    throw(e);    // 再抛出这个"异常"
} finally {
    释放资源代码块
}

try {
    // 可能发生异常的语句
} catch(ExceptionType e) {
    // 处理异常语句
}
try 块里声明的变量只是代码块内的局部变量，它只在 try 块内有效，其它地方不能访问该变量。
printStackTrace() 方法：指出异常的类型、性质、栈层次及出现在程序中的位置
getMessage() 方法：输出错误的性质。
toString() 方法：给出异常的类型与性质。
如果 try 语句块中发生异常，那么一个相应的异常对象就会被拋出，然后 catch 语句就会依据所拋出异常对象的类型进行捕获，并处理。处理之后，程序会跳过 try 语句块中剩余的语句，转到 catch 语句块后面的第一条语句开始执行。
如果 try 语句块中没有异常发生，那么 try 块正常结束，后面的 catch 语句块被跳过，程序将从 catch 语句块后的第一条语句开始执行。

try {
    // 可能会发生异常的语句
} catch(ExceptionType e) {
    // 处理异常语句
} catch(ExceptionType e) {
    // 处理异常语句
} catch(ExceptionType e) {
    // 处理异常语句
...
}
在多个 catch 代码块的情况下，当一个 catch 代码块捕获到一个异常时，其它的 catch 代码块就不再进行匹配。

当捕获的多个异常类之间存在父子关系时，捕获异常时一般先捕获子类，再捕获父类。所以子类异常必须在父类异常的前面，否则子类捕获不到

1. 当对不存在继承关系的对象进行强制类型转换时，会抛出 Java 强制类型转换（java.lang.ClassCastException）异常
2. finally块中的语句，在try或catch中的return语句执行之后、返回之前执行。而且finally语句中的“干扰”可能或不可能影响try、catch中return已经确定的返回值。若finally中也有return则覆盖try、catch中的return语句直接返回。
3. 使用 throws 声明抛出异常的思路是，当前方法不知道如何处理这种类型的异常，该异常应该由向上一级的调用者处理；如果 main 方法也不知道如何处理这种类型的异常，也可以使用 throws 声明抛出异常，该异常将交给 JVM 处理。JVM 对异常的处理方法是，打印异常的跟踪栈信息，并中止程序运行，这就是前面程序在遇到异常后自动结束的原因。
4. 子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相同，子类方法声明抛出的异常不允许比父类方法声明抛出的异常多。

throw ExceptionObject;

throws 关键字和 throw 关键字在使用上的几点区别如下：
1、throws 用来声明一个方法可能抛出的所有异常信息，表示出现异常的一种可能性，但并不一定会发生这些异常；throw 则是指拋出的一个具体的异常类型，执行 throw 则一定抛出了某种异常对象。
通常在一个方法（类）的声明处通过 throws 声明方法（类）可能拋出的异常信息，而在方法（类）内部通过 throw 声明一个具体的异常信息。
2、throws 通常不用显示地捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法； throw 则需要用户自己捕获相关的异常，而后再对其进行相关包装，最后将包装后的异常信息抛出。

多异常捕获

try{
    // 可能会发生异常的语句
} catch (IOException | ParseException e) {
    // 调用方法methodA处理
}

// 捕获多异常时，异常变量默认有final修饰
// 所以下面代码有错
e = new ArithmeticException(“test”);
// 捕获一种类型的异常时，异常变量没有final修饰
// 所以下面代码完全正确
e = new RuntimeException(“test”);

自定义异常

实现自定义异常类需要继承 Exception 类或其子类，如果自定义运行时异常类需继承 RuntimeException 类或其子类。

自定义异常的语法形式为：
<class><自定义异常名><extends><Exception>
在编码规范上，一般将自定义异常类的类名命名为 XXXException，其中 XXX 用来代表该异常的作用。

自定义异常类一般包含两个构造方法：一个是无参的默认构造方法，另一个构造方法以字符串的形式接收一个定制的异常消息，并将该消息传递给超类的构造方法。

class IntegerRangeException extends Exception {
    public IntegerRangeException() {
        super();
    }
    public IntegerRangeException(String s) {
        super(s);
    }
}

异常跟踪栈

异常对象的 printStackTrace() 方法用于打印异常的跟踪栈信息，根据 printStackTrace() 方法的输出结果，开发者可以找到异常的源头，并跟踪到异常一路触发的过程。

Exception in thread “main” Test.SelfException: 自定义异常信息
at Test.PrintStackTraceTest.thirdMethod(PrintStackTraceTest.java:26)
at Test.PrintStackTraceTest.secondMethod(PrintStackTraceTest.java:22)
at Test.PrintStackTraceTest.firstMethod(PrintStackTraceTest.java:18)
at Test.PrintStackTraceTest.main(PrintStackTraceTest.java:14)
第 2 行到第 5 行之间的内容是异常跟踪栈信息，从打印的异常信息我们可以看出，异常从 thirdMethod 方法开始触发，传到 secondMethod 方法，再传到 firstMethod 方法，最后传到 main 方法，在 main 方法终止，这个过程就是 Java 的异常跟踪栈

Java.util.logging：JDK自带记录日志类

如果要生成简单的日志记录，可以使用全局日志记录器并调用其 info 方法，代码如下：

Logger.getGlobal().info("打印信息");

Collection

Collection 接口是 List、Set 和 Queue 接口的父接口，通常情况下不被直接使用

方法名称 说明
boolean add(E e) 向集合中添加一个元素，如果集合对象被添加操作改变了，则返回 true。E 是元素的数据类型
boolean addAll(Collection c) 向集合中添加集合 c 中的所有元素，如果集合对象被添加操作改变了，则返回 true。
void clear() 清除集合中的所有元素，将集合长度变为 0。
boolean contains(Object o) 判断集合中是否存在指定元素
boolean containsAll(Collection c) 判断集合中是否包含集合 c 中的所有元素
boolean isEmpty() 判断集合是否为空
Iteratoriterator() 返回一个 Iterator 对象，用于遍历集合中的元素
boolean remove(Object o) 从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，该方法只删除第一个符合条件的元素，该方法将返回 true。
boolean removeAll(Collection c) 从集合中删除所有在集合 c 中出现的元素（相当于把调用该方法的集合减去集合 c）。如果该操作改变了调用该方法的集合，则该方法返回 true。
boolean retainAll(Collection c) 从集合中删除集合 c 里不包含的元素（相当于把调用该方法的集合变成该集合和集合 c 的交集），如果该操作改变了调用该方法的集合，则该方法返回 true。
int size() 返回集合中元素的个数
Object[] toArray() 把集合转换为一个数组，所有的集合元素变成对应的数组元素。

package com.list;
import java.util.*;
public class Muster {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Collection <String> list= new ArrayList<>();//实例化Collection接口
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list.size());
		Iterator <String> it=list.iterator();
		while(it.hasNext()) {
			String str=(String)it.next();
			System.out.println(str);
		}

}
}

List集合

public static void main(String[] args) {
    ArrayList list1 = new ArrayList(); // 创建集合 list1
    ArrayList list2 = new ArrayList(); // 创建集合 list2
    list1.add("one");
    list1.add("two");
    list1.add("three");
    System.out.println("list1 集合中的元素数量：" + list1.size()); // 输出list1中的元素数量
    list2.add("two");
    list2.add("four");
    list2.add("six");
    System.out.println("list2 集合中的元素数量：" + list2.size()); // 输出list2中的元素数量
    list2.remove(2); // 删除第 3 个元素
    System.out.println("\nremoveAll() 方法之后 list2 集合中的元素数量：" + list2.size());
    System.out.println("list2 集合中的元素如下：");
    Iterator it1 = list2.iterator();
    while (it1.hasNext()) {
        System.out.print(it1.next() + "、");
    }
    list1.removeAll(list2);
    System.out.println("\nremoveAll() 方法之后 list1 集合中的元素数量：" + list1.size());
    System.out.println("list1 集合中的元素如下：");
    Iterator it2 = list1.iterator();
    while (it2.hasNext()) {
        System.out.print(it2.next() + "、");
    }
}

retainAll( ) 方法的作用与 removeAll( ) 方法相反，即保留两个集合中相同的元素，其他全部删除。

List

List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类

List<> list=new ArrayList<>();
List<> list=new LinkedList<>();

package com.list;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

public class Gather {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//实例化List集合
		List<String> list=new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		int i=(int) (Math.random()*list.size());
		System.out.println(list.get(i));
		list.remove(2);
		Iterator it1=list.iterator();
		while(it1.hasNext()) {
			String str=(String)it1.next();
			System.out.println(str);
		}
	}
}

ArrayList类的常用方法
方法名称 说明

• E get(int index) 获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
• int index(Object o) 返回此集合中第一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
• int lastIndexOf(Object o) 返回此集合中最后一次出现指定元素的索引，如果此集合不包含该
  元素，则返回 -1
• E set(int index, Eelement) 将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素
• List subList(int fromlndex, int tolndex) 返回一个新的集合，新集合中包含 fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的元素

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;



public class Test {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Product pd1=new Product(4,"木",10);
Product pd2=new Product(5,"水",11);
Product pd3=new Product(6,"火",12);
List list=new ArrayList<>();//类的对象创建顺序表是不需要指明元素类型
list.add(pd1);
list.add(pd2);
list.add(pd3);
for(int i=0;i<list.size();i++) {
	Product product=(Product)list.get(i);//强制转换Product类型
	/*获取的值为 Object 类，因此需要将该值转换为 Product 类*/
	System.out.println(product);
}
List list1=new ArrayList();
list1.add("one");
list1.add("|");
list1.add("two");
list1.add("|");
list1.add("three");
list1.add("|");
list1.add("Four");
System.out.println(list1.size());
Iterator it1=list1.iterator();
while(it1.hasNext()) {
	String str=(String)it1.next();
	System.out.println(str);
}
System.out.println(list1.indexOf("|"));
System.out.println(list1.lastIndexOf("|"));
List list2=new ArrayList();
list2.add("one");
list2.add("two");
list2.add("three");
list2.add("four");
list2.add("five");
list2.add("six");
list2.add("seven");
System.out.println(list2.size());
Iterator it2=list2.iterator();
while(it2.hasNext()) {
	String str=(String)it2.next();
	System.out.println(str);
}
List sublist=new ArrayList();
sublist=list2.subList(2, 5);
System.out.println(sublist.size());
Iterator it3=sublist.iterator();
while(it3.hasNext()) {
	String str=(String)it3.next();
	System.out.println(str);
}
	}
}

LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高

LinkList类中的方法
方法名称	说明
void addFirst(E e)	将指定元素添加到此集合的开头
void addLast(E e)	将指定元素添加到此集合的末尾
E getFirst()	返回此集合的第一个元素
E getLast()	返回此集合的最后一个元素
E removeFirst()	删除此集合中的第一个元素
E removeLast()	删除此集合中的最后一个元素

LinkedList 中的 是 Java 中的泛型，用于指定集合中元素的数据类型，例如这里指定元素类型为 String，则该集合中不能添加非 String 类型的元素。

package com.list;

import java.util.LinkedList;
import java.util.List;

public class Test1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		LinkedList<String> products=new LinkedList<String> ();
		String p1=new String("六角");
		String p2=new String("10A");
		String p3=new String("卷尺");
		String p4=new String("模板");
		products.add(p1);
		products.add(p2);
		products.add(p3);
		products.add(p4);
		String p5=new String("小柜");
		products.addLast(p5);
		for(int i=0;i<products.size();i++) {
			System.out.println(products.get(i));
		}
		System.out.println(products.getFirst());
		System.out.println(products.getLast());
		products.removeLast();
		for(int i=0;i<products.size();i++) {
			System.out.println(products.get(i));
		}
	}

}

ArrayList 类和 LinkedList 类的区别

• ArrayList 是基于动态数组数据结构的实现，访问元素速度优于 LinkedList。LinkedList 是基于链表数据结构的实现，占用的内存空间比较大，但在批量插入或删除数据时优于 ArrayList。
• 对于快速访问对象的需求，使用 ArrayList 实现执行效率上会比较好。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高

HashSet

HashSet 具有以下特点：
不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。
集合元素值可以是 null。
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据该 hashCode 值决定该对象在 HashSet 中的存储位置。如果有两个元素通过 equals() 方法比较返回的结果为 true，但它们的 hashCode 不相等，HashSet 将会把它们存储在不同的位置，依然可以添加成功。
也就是说，两个对象的 hashCode 值相等且通过 equals() 方法比较返回结果为 true，则 HashSet 集合认为两个元素相等。

HashSet hs = new HashSet();    // 调用无参的构造函数创建HashSet对象
HashSet<String> hss = new HashSet<String>();    // 创建泛型的 HashSet 集合对象

package com.list;

import java.util.HashSet;
import java.util.Iterator;

public class Test2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
HashSet<String> cour=new HashSet<String>();
String s1=new String("JAVA");
String s2=new String("Python");
String s3=new String("C++");
String s4=new String("GO");
cour.add(s1);
cour.add(s2);
cour.add(s3);
cour.add(s4);
Iterator it=cour.iterator();
while(it.hasNext()) {
	System.out.println((String)it.next());
}
System.out.println(cour.size());
	}
}

首先使用 HashSet 类的构造方法创建了一个 Set 集合，接着创建了 4 个 String 类型的对象，并将这些对象存储到 Set 集合中。使用 HashSet 类中的 iterator() 方法获取一个 Iterator 对象，并调用其 hasNext() 方法遍历集合元素，再将使用 next() 方法读取的元素强制转换为 String 类型。最后调用 HashSet 类中的 size() 方法获取集合元素个数。**

如果向 Set 集合中添加两个相同的元素，则后添加的会覆盖前面添加的元素，即在 Set 集合中不会出现相同的元素。

**

TreeSet 类

TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序(升序).
TreeSet 只能对实现了 Comparable 接口的类对象进行排序

实现Comparable接口类对象的比较方式
类 比较方式
包装类（BigDecimal、Biglnteger、 Byte、Double、
Float、Integer、Long 及 Short) 按数字大小比较
Character 按字符的 Unicode 值的数字大小比较
String 按字符串中字符的 Unicode 值的数字大小比较

TreeSet类的常用方法
方法名称 说明
E first() 返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型
E last() 返回此集合中的最后一个元素
E poolFirst() 获取并移除此集合中的第一个元素
E poolLast() 获取并移除此集合中的最后一个元素
SortedSet subSet(E fromElement,E toElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement
对象之间的所有对象。包含 fromElement 对象，不包含 toElement 对象
SortedSet headSet<E toElement〉 返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。不包含 toElement 对象
SortedSet tailSet(E fromElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象

TreeSet是自然排序，升序，这个是默认进行的，在创建TreeSet实例化对象时，就已经进行了。不需要人为操作
在使用自然排序时只能向 TreeSet 集合中添加相同数据类型的对象，否则会抛出 ClassCastException 异常。如果向 TreeSet 集合中添加了一个 Double 类型的对象，则后面只能添加 Double 对象，不能再添加其他类型的对象

package com.list;
import java.util.Iterator;
import java.util.Scanner;
import java.util.SortedSet;
import java.util.TreeSet;
public class Test3 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
TreeSet<Double>scores=new TreeSet<Double>();
Scanner input =new Scanner(System.in);
for(int i=0;i<5;i++) {
	System.out.println("第"+i+"个的成绩:");
	double score=input.nextDouble();
//将学生成绩转换为Double类型，添加到TreeSet集合中
	scores.add(Double.valueOf(score));
}
Iterator<Double>it=scores.iterator();
System.out.println("学生成绩:");
while(it.hasNext()) {
	System.out.println(it.next());
}
System.out.println("查询");
	double search=input.nextDouble();
	if(scores.contains(search)) {
		System.out.println(search+"存在");
	}else {
		System.out.println(search+"不存在");
	}
	SortedSet<Double> score1=scores.headSet(60.0);//不包括60.0
	System.out.println("\n不及格成绩:");
	for(int i=0;i<score1.toArray().length;i++) {
		System.out.println(score1.toArray()[i]+"\t");
	}
	SortedSet<Double>score2=scores.tailSet(90.0);//包括90.0
	System.out.println("\n优秀成绩:");
	for(int i=0;i<score2.toArray().length;i++) {
		System.out.println(score2.toArray()[i]+"\t");
	}
	SortedSet<Double>score3=scores.subSet(60.0, 100.0);//不包含100.0
	System.out.println("\n从60-100之间的成绩有");
	for(int i=0;i<score3.toArray().length;i++) {
		System.out.println(scores.toArray()[i]+"\t");
	}
}
	}

Map

Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。
Map 集合里保存着两组值，一组值用于保存 Map 里的 key，另外一组值用于保存 Map 里的 value，key 和 value 都可以是任何引用类型的数据。Map 的 key 不允许重复，value 可以重复
Map 中的 key 和 value 之间存在单向一对一关系，即通过指定的 key，总能找到唯一的、确定的 value。从 Map 中取出数据时，只要给出指定的 key，就可以取出对应的 value。
Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。

 Map接口的常用方法
方法名称	说明
void clear()	删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key)	查询 Map 中是否包含指定的 key，如果包含则返回 true。
boolean containsValue(Object value)	查询 Map 中是否包含一个或多个 value，如果包含则返回 true。
V get(Object key)	返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型
V put(K key, V value)	向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。
void putAll(Map m)	将指定 Map 中的 key-value 对复制到本 Map 中。
V remove(Object key)	从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null
boolean remove(Object key, Object value)	这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。
Set entrySet()	返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
Set keySet()	返回 Map 集合中所有键对象的 Set 集合
boolean isEmpty()	查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。
int size()	返回该 Map 里 key-value 对的个数
Collection values()	返回该 Map 里所有 value 组成的 Collection

foreach遍历对象
for (Object obj : objs) {
}

遍历Map

1）在 for 循环中使用 entries 实现 Map 的遍历（最常见和最常用的）。

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("Java入门教程", "http://c.biancheng.net/java/");
    map.put("C语言入门教程", "http://c.biancheng.net/c/");
    for (Map.Entry<String, String> entry : map.entrySet()) {
        String mapKey = entry.getKey();
        String mapValue = entry.getValue();
        System.out.println(mapKey + "：" + mapValue);
    }
}

2）使用 for-each 循环遍历 key 或者 values，一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好。

Map<String, String> map = new HashMap<String, String>();
map.put("Java入门教程", "http://c.biancheng.net/java/");
map.put("C语言入门教程", "http://c.biancheng.net/c/");
// 打印键集合
for (String key : map.keySet()) {
    System.out.println(key);
}
// 打印值集合
for (String value : map.values()) {
    System.out.println(value);
}

3）使用迭代器（Iterator）遍历

Map<String, String> map = new HashMap<String, String>();
map.put("Java入门教程", "http://c.biancheng.net/java/");
map.put("C语言入门教程", "http://c.biancheng.net/c/");
Iterator<Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Entry<String, String> entry = entries.next();
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + ":" + value);
}

4）通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作。

for(String key : map.keySet()){
    String value = map.get(key);
    System.out.println(key+":"+value);
}

Collections操作

排序

Collections 提供了如下方法用于对 List 集合元素进行排序。 void reverse(List list)：对指定 List
集合元素进行逆向排序。 void shuffle(List list)：对 List 集合元素进行随机排序（shuffle
方法模拟了“洗牌”动作）。 void sort(List list)：根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
void sort(List list, Comparator c)：根据指定 Comparator 产生的顺序对 List
集合元素进行排序。 void swap(List list, int i, int j)：将指定 List 集合中的 i 处元素和 j
处元素进行交换。 void rotate(List list, int distance)：当 distance 为正数时，将 list
集合的后 distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance
个元素“整体”移到后面。该方法不会改变集合的长度。

查找、替换操作

Collections 还提供了如下常用的用于查找、替换集合元素的方法。
int binarySearch(List list, Object key)：使用二分搜索法搜索指定的 List 集合，以获得指定对象在 List 集合中的索引。如果要使该方法可以正常工作，则必须保证 List 中的元素已经处于有序状态。
Object max(Collection coll)：根据元素的自然顺序，返回给定集合中的最大元素。
Object max(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最大元素。
Object min(Collection coll)：根据元素的自然顺序，返回给定集合中的最小元素。
Object min(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最小元素。
void fill(List list, Object obj)：使用指定元素 obj 替换指定 List 集合中的所有元素。
int frequency(Collection c, Object o)：返回指定集合中指定元素的出现次数。
int indexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中第一次出现的位置索引；如果父 List 中没有出现这样的子 List，则返回 -1。
int lastIndexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中最后一次出现的位置索引；如果父 List 中没有岀现这样的子 List，则返回 -1。
boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值 newVal 替换 List 对象的所有旧值 oldVal。

复制

Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。

copy() 方法的语法格式如下：
void copy(List <? super T> dest,List<? extends T> src)

其中，dest 表示目标集合对象，src 表示源集合对象。

不可变集合

Set set = Set.of("Java", "Kotlin", "Go", "Swift");
List list = List.of(34, -25, 67, 231);
Map map = Map.of("语文", 89, "数学", 82, "英语", 92);
Map map2 = Map.ofEntries(Map.entry("语文", 89), Map.entry("数学", 82), Map.entry("英语", 92));

泛型

package com.fanxing;

public class Test<T> {
private T over;
private T getover() {
	return over;
}
private void setover(T over) {
	this.over=over;
}
public static void main(String[] args) {
	Test<Boolean>o1=new Test<Boolean>();//实例化一个Boolean对象
	Test<Float>o2=new Test<Float>();
	o1.setover(true);
	o2.setover(12.1f);
	System.out.println((o1.getover() instanceof Boolean)?"是的":"不是");
	System.out.println((o2.getover() instanceof Float)?"是的":"不是");
}
}

定义泛型类时，一般类型名称用T，容器元素用E表达

多个泛型定义

类型<T1,T2>

泛型数组定义

package com.fanxing;
public class Test1 <T>{
private T[] array;
public void Set(T[] array) {
	this.array=array;
}
public T[] Get() {
	return array;
}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
Test1<String>test=new Test1<String>();
String[] array=new String[] {"1","2","3","4"};
test.Set(array);
for(int i=0;i<array.length;i++) {
	System.out.println(test.Get()[i]);
}
	}
}

不能使用泛型类建立数组

泛型集合

使用K,V代表容器中的键值和与键值相对应的具体值。
例如：ArrayList、HashMap<K,V>、HashSet
泛型化在主方法中直接使用，不需要定义泛型类

package com.fanxing;
import java.util.HashMap;
import java.util.Map;
public class Test2<K,V> {
public Map<K,V>map=new HashMap<K,V>();
public void put(K k,V v) {
	map.put(k, v);
}
public V get(K k) {
	return map.get(k);
}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
Test2<Integer,String>test=new Test2<Integer,String>();
for(int i=0;i<5;i++) {
	test.put(i, "我是集合成员");
}
for(int i=0;i<test.map.size();i++) {
	System.out.println(test.map.get(i)+i);
}
	}
}

把一个对象“丢进”集合里之后，集合就会“忘记”这个对象的数据类型，当再次取出该对象时，该对象的编译类型就变成了 Object 类型
泛型本质上是提供类型的“类型参数”，也就是参数化类型。

package com.list;

import java.util.ArrayList;
import java.util.HashMap;

public class Test6 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
Book book1=new Book(1, "唐诗三百首", 8);
Book book2=new Book(2, "小星星", 12);
Book book3=new Book(3, "成语大全", 22);
HashMap<Integer,Book>books=new HashMap<Integer,Book>();
books.put(1001, book1);
books.put(1002, book2);
books.put(1003, book3);
for(Integer id:books.keySet()) {
	 System.out.print(id + "——");
	 System.out.println( books.get(id));// 不需要类型转换
}
ArrayList<Book>booklist=new ArrayList();
booklist.add(book1);
booklist.add(book2);
booklist.add(book3);
for(int i=0;i<booklist.size();i++) {
	 System.out.println( booklist.get(i));// 这里不需要类型转换
}
	}
}

泛型类

除了可以定义泛型集合之外，还可以直接限定泛型类的类型参数。语法格式如下：

public class class_name<data_type1,data_type2,…>{}

其中，class_name 表示类的名称，data_ type1 等表示类型参数。Java 泛型支持声明一个以上的类型参数，只需要将类型用逗号隔开即可。
泛型类一般用于类中的属性类型不确定的情况下。在声明属性时，使用下面的语句：

private data_type1 property_name1;
private data_type2 property_name2;

package com.list;
public class Test14 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Stu<String,Integer,Character>stu=new Stu<String,Integer,Character>("张晓玲", 28, '女');
	String name=stu.getName();
	Integer age=stu.getAge();
	Character sex=stu.getSex();
	 System.out.println("学生姓名：" + name + "，年龄：" + age + "，性别：" + sex);
	}
}