常量
类型
整数常量
所有的整数
0,1-99
小数常量
所有的小数
0.0,-1.11
字符常量
单引号引起来,只能写一个字符,必须有内容
‘a’,’ ‘,’.’,‘中’
字符串常量
双引号引起来,可以写多个字符,也可以不写
“”,“a”,“你好”
布尔常量
只有true和false
true, false
空常量
只有null，不能直接打印
null
变量
数据类型
关键字
内存占用
取值范围
字节型
byte
1个字节
-128~127
byte＋byte时会被转化为int
短整型
short
2个字节
-32768~32767
同上相加会被转化为int
整型
int（默认）
4个字节
-2^31~2^31-1
长整型
long
8个字节
-2^63~2^
字符后必须以’l’或’L’结尾，如:long num=300000L
单精度浮点数
float
4个字节
1.4013E-45~3.4028E+38
同上加’f’或’F’
双精度浮点数
double（默认）
8个字节
4.9E-324~1.7977E+308
字符型
char
2个字节
0-65535
同byte，相加会被转化为int
布尔类型
boolean
1个字节
true&false
转换
赋值时用不同的数值类型如果允许使用会自动转换类型，如：double k=0.5F;(将float赋值给double k)
强转：int k=(int)1.5;(把double 1.5强转为int 1然后赋值给int k)
定义方法 ：public static 返回类型 方法名(传入的值){具体方法}
1
2
3
public static int f1 ( int a ){ //public表示公开，static大概约等于func?
return a ;
}
名称相同输入不同的函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main {
public static void main ( String [] args ) {
int a = 0 ;
System . out . println ( sum ( 1.0f , 4.0f , 5.0f ));
}
public static int sum ( int a , int b ){
return a + b ;
}
public static int sum ( int a , int b , int c ){
return a + b + c ;
}
public static float sum ( float a , float b ){
return a + b ;
}
public static float sum ( float a , float b , float c ){
return a + b + c ;
}
}
与c类似
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if (){
} else if (){
} else {
}
swich (){
case 常量 1 :
语句 1 ;
break ;
case 常量 2 :
语句 2 ;
break ;
default :
break ;
}
与c相同
1
2
3
4
5
6
7
8
9
10
11
for (;;){
}
while ( 条件 ){
}
do {
} while ( 条件 )
for-each
1
2
3
for ( int i : arr ) {
System . out . println ( arr [ i ]);
}
等同于
1
2
3
for i := range arr {
fmt . println ( arr [ i ])
}
定义数组 :数据类型[] 数组名 = new 数据类型[] {数据}
或者简写为:数据类型[] 数组名 ={数据}
1
2
int [] arr = new int []{ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
int [] arr = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
定义数组 :数据类型[] 数组名 = new 数据类型[数组初始长度];
1
int [] arr = new int [ 10 ];
假设数组名为arr
功能
写法
描述
长度
arr.length
得到arr的长度
转化为字符串打印
Arrays.toString(arr);
是java.util.Arrays的方法,返回一个字符串
查询
Arrays.asList(arr).contains(val)
同上包,查询数组arr中是否包含val返回boolean
合并
ArrayUtils.addAll(arr1, arr2)
合并数组arr1,arr2返回数组
倒置
ArrayUtils.reverse(intArray)
倒置数组无返回
删除
ArrayUtils.removeElement(intArray, val)
返回删除后数组
创建
1
2
3
4
5
6
//直接创建方式
String str1 = "abc" ;
//提供一个 字符数组 参数来初始化字符串
char [] strarray = { 'a' , 'b' , 'c' };
String str2 = new String ( strarray );
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
int len = str . length (); //获取长度
str1 = str1 . concat ( str2 ); //使str1+=str2,当然也可以直接这么写
int idx = str . indexOf ( str2 ); //字符串str2在str中首次出现的位置,从0开始计数,没找到就返回-1
int idx = str . lastIndexOf ( str2 ); //字符串str2在str中最后一次出现的位置,从0开始计数,没找到就返回-1
char thischar = str . charAt ( i ); //等于Go中的str[i]
String substr1 = str . substring ( i ); //同Go中的str[i:]
String substr2 = str . substring ( 2 , 4 ); //同Go中的str[i:j]
String str1 = str . trim (); //去首尾空格
String str = str . replace ( char oldChar , char newChar )
String str = str . replace ( String oldChar , String newChar ) //使字符串中的oldChar全部替换为newChar
//判断字符串始末的函数
String str = "abcde" ;
boolean res = str . startsWith ( "ab" ); //res为true
boolean res = str . StartsWith ( "bc" , 1 ); //res为true
boolean res = str . endsWith ( "de" ); //res为true
//判断是否相等
String str1 = "abcde" ;
String str2 = str1 ; //字符串str1和str2都是一个字符串对象
String str3 = "ABCDE" ;
boolean isEqualed = str1 . equals ( str2 ); //返回true
boolean isEqualed = str1 . equals ( str3 ); //返回false
boolean isEqualed = str1 . equlasIgnoreCase ( str3 ); //不在意大小写,所以返回true
String str1 = str1 . toUpperCase (); //转换为大写
String str3 = str2 . toLowerCase (); //转换为小写
//分割字符串
String [] res = str . split ( " " ); //res = {"Hello","World","A.B.C"}
String [] res = str . split ( " " , 2 ); //res = {"Hello","World A.B.C"}
String [] res = str . split ( "\\." ); //res = {"Hello World A","B","C"}
String [] res = str . split ( " |\\." ); //res = {"Hello World A","B","C"}
byte [] Str2 = Str1 . getBytes (); //转换为byte数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
String 转 int 型：
//第一种
int i = Integer . parseInt ( String str )
//第二种
int i = Integer . valueOf ( s ). intValue ();
String 转 long 型：
long l = Long . parseLong ( String str );
String 转 double 型：
double d = Double . valueOf ( String str ). doubleValue (); //doubleValue()不要也可
double d = Double . parseDouble ( str );
int 转 string 型：
//第一种
String s = String . valueOf ( i ) ；
//第二种
String s = Integer . toString ( i );
//第三种
String s = "" + i ;
StringBuilder可以理解为可变的string即对它的操作可以可以直接保留不需要用自己去接收
创建 ：StringBuilder sb= new StringBuilder();
StringBuilder sb= new StringBuilder("abc");
添加 ：sb=sb.append("aaa");
sb=sb.append('a');
删除指定位置字符 ：sb.delete(0,1);//sb=sb[1:]
sb.deleteCharAt(0);//删除sb[0]
翻转 ：sb.reverse();
替换 ：sb.replace(0,1,"haha~");//将sb[0:1]替换为haha~
插入 ：sb.insert(1,">.<");
sb.insert(1,'.')
sb.insert(1,2)
当前容量 ：sb.capacity();
长度 ：sb.length();
str.setLength(4);//设置长度为4
转变为String ：sb.toString()
定义 ：
一个元素存取有序的集合
带有索引(与数组的索引是一个道理)
可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
常用子类 ：
常用方法 ：
1.增加元素
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移
2.删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
3.替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
4.查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
List < String > list = new ArrayList < String >();
//1,添加元素。
list . add ( "小红" );
list . add ( "小梅" );
list . add ( "小强" );
//2,插入元素。插入元素前的集合["小红","小梅","小强"]
list . add ( 1 , "老王" ); //插入元素后的集合["小红","老王","小梅","小强"]
//3,删除元素。
list . remove ( 2 ); // 删除元素后的集合["小红","老王","小强"]
//4,修改元素。
list . set ( 1 , "隔壁老王" ); // 修改元素后的集合["小红","隔壁老王","小强"]
Iterator < String > it = list . iterator ();
for ( int i = 0 ; i < list . size (); i ++) {
String str = list . get ( i );
System . out . println ( str );
}
ListIterator是一种访问list的方法，另一个常用的迭代器是Iterator，因为Iterator在list的迭代中可能会出错所以用ListIterator。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList ;
import java.util.Iterator ;
public class RunoobTest {
public static void main ( String [] args ) {
// 创建集合
ArrayList < String > sites = new ArrayList < String >();
sites . add ( "Google" );
sites . add ( "Runoob" );
sites . add ( "Taobao" );
sites . add ( "Zhihu" );
// 获取迭代器
Iterator < String > it = sites . iterator ();
// 输出集合中的所有元素
while ( it . hasNext ()) {
System . out . println ( it . next ());
}
}
}
定义 ：ArrayList<Integer> arr=new ArrayList<>();
ArrayList<String> arr2=new ArrayList<>();
添加 ：arr.add(1);//在末尾添加一个'1’,有一个bool类型的返回值表示是否添加成功,可以省略
arr.add(0,2);//在arr[0]处添加添加'2’,后移arr[1]之后的数,有一个bool类型的返回值,比如越界了就会返回false
访问 ：srr.get(2)//返回arr[2]
修改 ：arr.set(2,99)//将arr[2]替换为99返回arr[2]替换前的值
删除 ：arr.remove(1)//移除arr[1],返回删除前的arr[1],如果越界了会编译失败
长度 ：arr.size()//len(arr)
*ArrayList可以被for-each遍历
创建 ：LinkedList<String> sites = new LinkedList<String>();//创建一个名为sites的string类型的链表
添加 ：
sites.add("Google");//在尾部添加"Google"sites.add(1,"wiki");//在add[1]的位置添加"wiki"sites.addFirst("Wiki");//在头部添加"wiki"sites.addLast("Wiki");//在尾部添加"wiki"
定义：
不允许存储重复的元素
没有索引，没有带索引的方法 ，也不能使用普通的for循环遍历
定义 ：
不允许存储重复的元素
没有索引，没有带索引的方法，也不能使用普通的for循环遍历
是一个无序的集合，存储元素和取出元素的顺序有可能不一致
底层是一个哈希表结构(查询的速度非常快)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main ( String [] args ) {
//创建
Set < Integer > set = new HashSet <>();
//使用add方法往集合中添加元素
set . add ( 1 );
set . add ( 3 );
set . add ( 2 );
set . add ( 1 );
//使用迭代器遍历Set集合
Iterator < Integer > it = set . iterator ();
while ( it . hasNext ()){
Integer n = it . next ();
System . out . println ( n ); //1,2,3 无序且不重复
}
}
做到不重复的方法 ：Set集合在调用add方法的时候，add方法会调用元素hashCode方法和equals方法，判断元素是否重复
Map<key,value>
创建 ：
Map<String,int> map = new HashMap<String,String>();创建一个名为map，索引为string，值为int的Map
添加 ：
map.put("a", 1);//当给Map中添加元素，会返回key对应的原来的value值，若key没有对应的值，返回null
获取 ：
int en = map.get("a");//根据指定的key获取对应的value
删除 ：
int value = map.remove("a");//根据key删除元素,会返回key对应的value值
遍历键找值 ：
1
2
3
4
5
6
7
8
Iterator < String > it = keySet . iterator ();
while ( it . hasNext ()){
//得到每一个key
String key = it . next ();
//通过key获取对应的value
int value = map . get ( key );
System . out . println ( key + "=" + value );
}
Entry是Map接口中提供的一个静态内部嵌套接口，在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
方法 ：
getKey()方法：获取Entry对象中的键
getValue()方法：获取Entry对象中的值
entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//键值对的创建与遍历
public class MapDemo {
public static void main ( String [] args ) {
//创建Map对象
Map < String , String > map = new HashMap < String , String >();
//给map中添加元素
map . put ( "邓超" , "孙俪" );
map . put ( "李晨" , "范冰冰" );
map . put ( "刘德华" , "柳岩" );
//获取Map中的所有key与value的对应关系
Set < Map . Entry < String , String >> entrySet = map . entrySet ();
//遍历Set集合
Iterator < Map . Entry < String , String >> it = entrySet . iterator ();
while ( it . hasNext ()){
//得到每一对对应关系
Map . Entry < String , String > entry = it . next ();
//通过每一对对应关系获取对应的key
String key = entry . getKey ();
//通过每一对对应关系获取对应的value
String value = entry . getValue ();
System . out . println ( key + "=" + value );
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
/*
* 斗地主洗牌发牌排序
*/
public class Main {
public static void main ( String [] args ) {
//准备花色
ArrayList < String > color = new ArrayList < String >();
color . add ( "♠" );
color . add ( "♥" );
color . add ( "♦" );
color . add ( "♣" );
//准备数字
ArrayList < String > number = new ArrayList < String >();
Collections . addAll ( number , "3" , "4" , "5" , "6" , "7" , "8" , "9" , "10" , "J" , "Q" , "K" , "A" , "2" );
//定义一个map集合：用来将数字与每一张牌进行对应
HashMap < Integer , String > map = new HashMap < Integer , String >();
int index = 0 ;
for ( String thisNumber : number ) {
for ( String thisColor : color ) {
map . put ( index ++, thisColor + thisNumber );
}
}
//加入大小王
map . put ( index ++, "小☺" );
map . put ( index ++, "大☻" );
//一副54张的牌 ArrayList里边为0-53的数的新牌
ArrayList < Integer > cards = new ArrayList < Integer >();
for ( int i = 0 ; i <= 53 ; i ++) {
cards . add ( i );
}
//洗牌
Collections . shuffle ( cards );
//创建三个玩家和底牌
ArrayList < Integer > iPlayer = new ArrayList < Integer >();
ArrayList < Integer > iPlayer2 = new ArrayList < Integer >();
ArrayList < Integer > iPlayer3 = new ArrayList < Integer >();
ArrayList < Integer > iCards = new ArrayList < Integer >();
//遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和底牌中
for ( int i = 0 ; i < cards . size (); i ++) {
if ( i >= 51 ) {
iCards . add ( cards . get ( i ));
} else {
if ( i % 3 == 0 ) {
iPlayer . add ( cards . get ( i ));
} else if ( i % 3 == 1 ) {
iPlayer2 . add ( cards . get ( i ));
} else {
iPlayer3 . add ( cards . get ( i ));
}
}
}
//对每个人手中的牌排序
Collections . sort ( iPlayer );
Collections . sort ( iPlayer2 );
Collections . sort ( iPlayer3 );
//对应数字形式的每个人手中的牌，定义字符串形式的牌
ArrayList < String > sPlayer = new ArrayList < String >();
ArrayList < String > sPlayer2 = new ArrayList < String >();
ArrayList < String > sPlayer3 = new ArrayList < String >();
ArrayList < String > sCards = new ArrayList < String >();
for ( Integer key : iPlayer ) {
sPlayer . add ( map . get ( key ));
}
for ( Integer key : iPlayer2 ) {
sPlayer2 . add ( map . get ( key ));
}
for ( Integer key : iPlayer3 ) {
sPlayer3 . add ( map . get ( key ));
}
for ( Integer key : iCards ) {
sCards . add ( map . get ( key ));
}
//看牌
System . out . println ( sPlayer );
System . out . println ( sPlayer2 );
System . out . println ( sPlayer3 );
System . out . println ( sCards );
}
}
定义一个学生类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class stu {
String name ;
private int age ; //private关键字使其不能被直接访问
//干饭方法
public void eat (){
System . out . println ( "干饭" );
}
//睡觉方法
public void sleep (){
System . out . println ( "呼呼呼" );
}
}
类的使用:
1
2
3
4
public static void main ( String [] args ) {
stu b = new stu (); //申请空间
b . eat (); //调用方法
}
特别的调用类的方法时会调用类定义时的地址。
应对在传入值和类中变量名相同的情况。
1
2
3
4
5
6
7
8
9
10
11
public class Person {
String name ;
public void sayhello ( String name ){
System . out . println ( name + "你好，我的名字叫" + this . name );
}
}
//
Person p = new Person ();
p . name = "p1" ;
p . sayhello ( p2 ); //打印结果为“p2你好，我的名字叫p1”
判断该变量是否是(属于)某个类
1
2
3
4
5
6
7
public class Main {
public static void main ( String [] args ) {
zi zi = new zi ();
boolean ok = zi instanceof fu ;
System . out . println ( ok );
}
}
不把定义出来的变量赋值给一个特定的符号，基本上算是一次性的变量。
比如new zi(18).show();
即定义在类内部的类，其中的sun，就是内部类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class zi {
int age = 20 ;
zi (){}
zi ( int a ){
age = a ;
}
public void show (){
System . out . println ( age );
}
//内部类
class sun {
public void yeye (){
System . out . println ( "爷爷" );
}
}
}
调用内部类 ：zi.sun sun = new zi().new sun();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//父类
public class fu {
int age = 40 ;
public void show (){
System . out . println ( age );
}
}
//子类
public class zi extends fu { //extends表示继承于fu
int age = 20 ;
public void show (){ //函数show()重写
int age = 10 ;
System . out . println ( age );
System . out . println ( this . age );
System . out . println ( super . age ); //super使用父类的age
super . show (); //super使用父类的show
}
}
同种类型在不同继承下的多种形态
1
2
3
4
5
6
7
8
9
//fu、zi的定义同上题
public class Main {
public static void main ( String [] args ) {
fu f = new fu (); //定义为fu使用了fu的类
fu z = new zi (); //定义为fu使用了zi的类
f . show ();
z . show ();
}
}
在多种继承下，多态的体现就会更加明显(没卵用)
父类知道子类具有某个函数，但不知道其具体内容时，就可以使用抽象类来定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
abstract class Developer {
public abstract void work (); //抽象函数。
}
//JavaEE工程师
class JavaEE extends Developer {
public void work () {
System . out . println ( "正在研发淘宝网站" );
}
}
//Android工程师
class Android extends Developer {
public void work () {
System . out . println ( "正在研发淘宝手机客户端软件" );
}
}
不同go中接口主要用作万能类型，java中的接口为对其子类中函数的实现声明。
用implements表示继承于接口，一个子类可以继承多个接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
interface fu {
public void show ();
public void old ();
public int sum ( int a , int b );
}
public class zi implements fu {
int age = 20 ;
public void show (){
int age = 10 ;
System . out . println ( age );
System . out . println ( this . age );
}
public void old (){
System . out . println ( age );
}
public int sum ( int a , int b ){
return a + b ;
}
}
------------------------------ 一个子类继承多个接口示例 --------------------------------
interface Fu1
{
void show1 ();
}
interface Fu2
{
void show2 ();
}
class Zi implements Fu1 , Fu2 // 多实现。同时实现多个接口。
{
public void show1 (){}
public void show2 (){}
}
在函数定义时执行的函数，写法为类名()，可以有多个。
1
2
3
4
5
6
7
8
9
10
11
public class zi {
int age = 20 ;
zi (){} //空构造函数
zi ( int a ){
age = a ;
}
public void show (){
System . out . println ( age );
}
}
权限修饰符
访问控制修饰符 ：只有public，protected，default，private
作用： 用于控制被修饰变量、方法、类的可见范围.
public 的访问级别是最高的，其次是 protected、默认和 private.
成员变量和成员方法可以处于4个访问级别中的一个：公开、受保护、默认或私有.
存在继承关系时，父类不可以是 private，因为子类无法继承
顶层类可以处于公开或默认级别，顶层类不能被 protected 和 private 修饰.
局部变量不能被访问控制修饰符修饰
状态修饰符
final 类 ：
提示常量,被final修饰后无法再做改变
static ：
表示静态变量,即该变量被所有该类型的变量共享
abstract 修饰符 ：
提示抽象类(详见"类-抽象类")
用{}表示，控制变量作用范围。
局部代码块 ：出了{}，里面的变量就要重新定义。
构造代码块 ：优先于构造方法，主要用于赋初始值，每创建一个一个对象就会运行一次，一般用于初始化赋值
静态代码块 ：优先于类的主方法、构造方法运行，只运行一次，一般用于静态变量的初始化赋值
Java代码在运行时期发生的问题称作异常。
异常发生的原因有很多，通常包含以下三类：
用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。
这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
**检查性异常：**最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
异常体系：
Error ：不应该试图捕获的严重问题，大多数这样的错误都是异常条件，它们在Java程序处理的范畴之外。
RuntimeException ：是编译期间未经检查的异常，在正常运行中可以抛出的超类，该类异常出现时会结束程序，输出错误信息、位置
格式：
1
2
3
4
5
6
7
8
try {
可能出现的异常的代码 ;
} catch ( 异常变量类名 变量名 ){
异常的处理办法 ;
}
finally {
一定会被执行的语句。
}
程序在try中执行时如果遇到异常，会自动生成一个异常类对象 ，当java运行时系统接收到异常对象时，会去catch里找匹配的异常类，找到后就会进行异常处理，处理完毕后程序还会继续运行。
实例
1
2
3
4
5
6
7
8
9
10
11
12
int [] arr = { 1 , 2 , 3 };
try {
System . out . println ( arr [ 3 ]);
} catch ( ArrayIndexOutOfBoundsException e ){ //尝试捕捉到索引越界错误
System . out . println ( "索引越界" );
e . printStackTrace (); //同RuntimeException输出错误信息，但不停止运行
}
//如果无论如何都有释放内存，则在catch后面加上finally
finally {
arr = NULL ;
}
**try：**该代码块中编写可能产生异常的代码。
**catch：**用来进行某种异常的捕获，实现对捕获到的异常进行处理。
finally ：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
成员方法：
1
2
3
4
5
6
7
public String getMessage (); //返回此 throwable 的详细消息字符串
public String toString (); //获取异常类名和异常信息。
public void printStackTrace (); //获取异常类名和异常信息，以及异常出现在程序中的位置。
public void printStackTrace ( PrintStream s ); //通常用该方法将异常内容保存在日志文件中，以便查阅。
File实际上就是对String类型的路径的封装,在调用它的方法之后才会真正的操作文件。
File类的构造函数：
1
2
3
File ( String filePath ) //用输入的路径名来创建一个新的File变量
File ( String parentPath , String childPath ) //拼接输入的两个路径，使其成为一个string的类型
File ( File parentFile , String childPath ) //拼接一个File和一个输入的路径
实例：
1
2
3
4
5
6
7
String pathname = "E:\\java课\\杰哥不要.txt" ;
File p = new File ( "E:\\java课" );
File f1 = new File ( pathname );
File f2 = new File ( "E:\\java课" , "杰哥不要.txt" );
File f3 = new File ( p , "杰哥不要.txt" );
//f1,f2,f3的值都是"E:\java课\杰哥不要.txt"
File中的方法 ：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//创建文件对象
File file = new File ( "Test22.java" );
//获取文件的绝对路径，即全路径
String absPath = file . getAbsolutePath ();
//File中封装的路径是什么获取到的就是什么。
String path = file . getPath ();
//获取文件名称
String filename = file . getName ();
//获取文件大小
long size = file . length ();
File对文件的操作 ：
File file = new File("E:\\java课\\杰哥不要");
File dir = new File("E:\\有一个人前来买瓜");
File dir2 = new File("E:\\有一个人前来买瓜\\生异性吗\\你们哥俩");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//创建文件,如果文件存在,则返回false,如果路径错误则抛出异常IOException
boolean b1 = file . createNewFile ();
//删除文件(不是丢回收站,而是直接删除),删除成功返回true,文件不存在返回false
boolean b2 = file . delete ();
//判断文件是否存在,存在返回true,不存在false
boolean b3 = file . exists ();
//创建单个目录,已存在则返回false
boolean b4 = dir . mkdir ();
//创建多级目录,已存在则返回false
boolean b5 = dir . mkdirs ();
//删除目录时，如果目录中有内容，无法直接删除。
boolean b6 = dir . delete ();
//判断是否为文件,若不存在也会返回false
boolean b7 = file . isFile ();
//判断是否为文件夹,若不存在也会返回false
boolean b8 = dir . isDirectory ();
list() ：
String[] arr = dir.list();返回一个String数组,记录目录dir下所有文件名
listFiles() ：
File[] arr2 = dir.listFiles();返回一个File数组,得到目录dir下所有文件
注解，可以看作是对 一个 类/方法 的一个扩展的模版，每个 类/方法 按照注解类中的规则，来为 类/方法 注解不同的参数，在用到的地方可以得到不同的 类/方法 中注解的各种参数与值
java提供了5个基本的注解，分别是
1.@Override
限定父类重写方法:当子类重写父类方法时,子类可以加上这个注解,那这有什么什么用?这可以确保子类确实重写了父类的方法,避免出现低级错误
2.@Deprecated
标示已过时:这个注解用于表示某个程序元素类,方法等已过时,当其他程序使用已过时的类,方法时编译器会给出删除线,但不影响使用
3.@SuppressWarnings
抑制编译器警告:被该注解修饰的元素以及该元素的所有子元素取消显示编译器警告
4.@SafeVarargs
“堆污染"警告:堆污染就是把不带泛型的对象赋给一个带泛型的对象,因为不带泛型的话,默认会给泛型设定为object,意思就是什么类型都可以往里面塞,那你一个不带泛型的怎么可能给一个带泛型塞呢
5.@FunctionalInterface
函数式接口:什么是函数式?如果接口中只有一个抽象方法(可以包含多个默认方法或多个static方法)
接口体内只能声明常量字段和抽象方法,并且被隐式声明为public,static,final
接口里面不能有私有的方法或变量
这个注解有什么用?这个注解保证这个接口只有一个抽象方法,注意这个只能修饰接口
@Retention
这个注解是用来修饰注解定义的，作用是被修饰的注解可以保存多久，这个注解需要使用参数。
这个参数的类型是RetentionPolicy，所以使用这个注解就要对value赋值。
value的值有且仅有三个:
->RetenionPolicy.CLASS(默认) 编译器把该注解记录在class文件中,当运行java程序时,JVM不可获取注解信息
->RetenionPolicy.RUNTIME 编译器把该注解记录在class文件中,当运行java程序时,JVM可获取注解信息,程序可以通过反射获取该注解信息
->RetenionPolicy.SOURCE 该注解只保存在源代码中,编译器直接丢弃该注解
例如:@Retention(value=RetenionPolicy.SOURCE) 可简写为@Retention(RetenionPolicy.SOURCE)
2.@Target
@Target也只能修饰一个注解定义，作用是指定被修饰的注解能用于修饰什么东西,@Target也包含了一个value值，他的值只能是下面的:
取值
注解使用范围
ElementType.METHOD
可用于方法上
ElementType.TYPE
可用于类或者接口上
ElementType.ANNOTATION_TYPE
可用于注解类型上（被@interface修饰的类型）
ElementType.CONSTRUCTOR
可用于构造方法上
ElementType.FIELD
可用于域上
ElementType.LOCAL_VARIABLE
可用于局部变量上
ElementType.PACKAGE
用于记录java文件的package信息
ElementType.PARAMETER
可用于参数上
例如:
@Target(ElementType.METHOD) (这是简写)
@Target里面可以写多个值 因为它的源码是一个数组,如@Target({ElementType.METHOD,ElementType.TYPE})
public @interface Action()
上面就是他的用法，不过有个比较容易混淆的地方就是@interface和interface不是同一个东西:
@interface 不是interface,是注解类 是jdk1.5之后加入的,java没有给它新的关键字,所以就用@interface 这么个东西表示了 这个注解类，就是定义一个可用的注解,包括这个注解用于什么地方，是类，还是方法，还是property，还是方法入参等等,还有这个注解是否编译后进入class 比如我们知道的用于javadoc的注解,是不进入class文件的
然后在后面你就可以用这个注解写代码了。总的来说，这就是一个生成javadoc时用到的注释类
3.@Documented
这个注解用于指定被修饰的注解类将被javadoc工具提取成文档,如果定义注解类时使用了这个注解修饰,则所有使用该注解修饰的程序员苏API文档将会包含该注解说明
例如：@Documentedpublic @interface Testable{}
4.@Inherited
这个注解指定被他修饰的注解将具有继承性——如果某个类使用了@Xxx，则其子类将自动被@Xxx修饰
基本类型包装类
8种基本类型对应的包装类
基本类型 包装类
byte Byte
short Short
int Integer
log Long
float Float
double Double
char Character
boolean Boolean
自动装箱、自动拆箱
自动装箱:基本数值转成对象(int à Integer)
自动拆箱:对象转成基本数值(Integer à int)
常用方法
public int parseInt(String str):把字符串转成基本类型int
public static String toString(int x):把基本类型int转成字符串
public static Integer valueOf(int x):把基本类型i字符串转成Integer对象
public int intValue():以 int类型返回该包装类对象的值
System类: 系统属性信息工具类
public static long currentTimeMillis()：获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
public static void exit(int status)：用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态
public static void gc()：用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。
public static String getProperties()：用来获取指系统属性信息
Arrays类：数组操作工具类
public static void sort方法，用来对指定数组中的元素进行排序（元素值从小到大进行排序）
public static String toString方法，用来返回指定数组元素内容的字符串形式
public static void binarySearch方法，在指定数组中，查找给定元素值出现的位置。若没有查询到，返回位置为-插入点-1。要求该数组必须是个有序的数组
Math类：数学运算工具类
abs方法,结果都为正数
ceil方法，结果为比参数值大的最小整数的double值
floor方法，结果为比参数值小的最大整数的double值
max方法，返回两个参数值中较大的值
min方法，返回两个参数值中较小的值
pow方法，返回第一个参数的第二个参数次幂的值
round方法，返回参数值四舍五入的结果
random方法，产生一个大于等于0.0且小于1.0的double小数
快捷键
功能
Alt+Enter
导入包，自动修正代码
Ctrl+Y
删除光标所在行
Alt+/
补全代码提示
Ctrl+D
复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L
格式化代码
Ctrl+/
单行注释
Ctrl+Shift+/
选中代码注释，多行注释，再按取消注释
Alt+Ins
自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头
移动当前代码行
Ctrl+i+Alt+u
画出当前类的祖宗十八代
JDK9后的新方法，一个临时的逐行编译的编译器。
**使用：**在任意位置打开cmd窗口,输入JShell,即可运行。
1
2
3
4
5
6
7
8
9
10
C:\U sers\8 6187>JShell
jshell> System.out.println( "Hello World" ) ; //返回Hello World
jshell> int a = 10;
a == > 10
jshell> int b = a*10;
b == > 100
jshell> System.out.println( b) ; //返回100
AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。
AJAX 不是新的编程语言，而是一种使用现有标准的新方法。
AJAX 最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容。
AJAX 不需要任何浏览器插件，但需要用户允许JavaScript在浏览器上执行。
