Java 导论复习资料

Java特性

1. 简单
2. 面向对象
3. 平台独立：独立的字节码
4. 可移植
5. 高性能
6. 分布式
7. 安全
8. 健全
9. 多线程：运行程序使用线程同时执行多个任务
10. 动态性：在程序运行过程中，可以使用动态加载类块，并调用它的任意方法和属性

Java架构

1. 源文件
2. 类文件：编译后生成的.class文件，也就是字节码
3. JVM
4. 程序应用接口（API）

类的命名规则

1. 类名必须唯一
2. 类名只能包含下划线_、美元符号$、字母和数字，同时不能以数字开头
3. 不能包含关键字

类的命名约定

1. 类名应该为名词
2. 类名的第一个字母应该大写
3. 如果类名包含几个单词，则每个单词的第一个字母应该大写

Java文件的命名规则

1. 文件名唯一
2. 不能包含关键字
3. 如果文件包含多个类，则只有一个类可以声明为public
4. 如果类指定为public，则文件名和类名应该相同
5. 如果文件包含多个未声明为public的类，则可以为此文件指定任何的文件夹

整数数据类型

Warpper类（封装器类）

原生数据仅提供描述值，wapper额外提供了属性和方法，方便数据的使用

方法

访问说明符：确定能够从另一个类访问方法的范围
返回类型
方法名
参数列表
方法主体

对象

对象是类的实例，具有唯一标识
声明变量时，没有向它分配内存，只有创建对象后才分配内存，您需要使用new运算符调用类的构造函数，它会以类为模板创建新的对象，并返回对该内存位置的引用。

包

包的作用是根据相关性将他们归类
包名加上类名是类的完全限定名
相同名称的类可以放在不同的包下

访问说明符

private：只能在同一个类中访问
默认访问权限：只能由同一个包下的类访问
protected：只能由当前类以及继承自当前类的所有类访问
public：所有的类都可以访问

访问修饰符

final：用于方法、变量、类，使用final修饰的成员将不能再进行任何的修改
static：用于方法、变量、内部类，使用static修饰的成员，可以直接调用，与具体对象无关
abstract：用于方法、类，使用abstract修饰类，表示抽象类，不能被实例化；使用abstract修饰方法，表示抽象方法，不用实现函数体，具有由子类实现
native：用于方法，告诉编译器方法是由其他语言实现的，只需要导入JRE中即可

运算符和分支结构

int m = 4, n = 15;
while(m ++ < -- n) {
		
}
System.out.println(m + "," + n);

10,9

数组

数组的定义：数组是存储在相邻内存位置的单一数据类型的元素集合，数组的第一个元素的索引是0

int [] datas = new int[10];
datas[0] = 12;
datas[1] = 'a';
datas[2] = "1";		//错误

//声明数组
arraytype arrayname[] = new arraytype[size];
arraytype arrayname[] = {1,2,3};

//判断正误
String names[][] = new String[5][6];
String names[][] = new String[5][];
String names[][] = new String[][6];		//错误
String names[][] = {{"a","b"},{"c","d"},{"e","f"}};

枚举

枚举是特殊类型的类，可以有构造函数、方法、实例变量
不能使用new关键来创建枚举的实例

//错误
enum Mango {
	Carrie,Fairchild,Haden;
	private int price;
	Maingo(int p)
	{
		price = p;
	}
}
//正确
enum Mango {
	Carrie(10),Fairchild(9),Haden(12);
	private int price;
	Maingo(int p)
	{
		price = p;
	}
}

// for-each遍历枚举
enum Mango{Carrie, Fairchild, Haden};
class EnumTest
{
	public static void main(String args[]) {
		for(Mango p:Mango.values())
			System.out.println(p);
	}
}

字符串

String s1 = new String("Hello");
String s2 = new String("Hello");
1. s1 == s2 结果true			//错误
2. s1和s2指向同一个对象			//错误
3. s1.equals(s2)结果为true		//正确
4. s1 == "Hello" 结果为true		//错误

// 创建两个String对象
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);
// false
System.out.println(s1.equals(s2));
// true
// 同一个在字符串常量池中的对象
String s3 = "hello";
String s4 = "hello";
System.out.println(s3 == s4);
// true
System.out.println(s3.equeal(s4));
// true

"Hello"
//返回字符串内指定字符第一次出现的索引位置
indexOf('l')	//返回2
//删除字符串开头和结尾的空白，并返回删除后的字符串
trim()

StringBuilder和StringBuffer类
这些类称为不可变类，因为在操作时，他们不创建任何string对象

通过StringBuilder和StringBuffer类使用字符串执行各种操作
StringBuilder和StringBuffer类具有相同的方法，但是，StringBuffer类中的方法已同步

获取当前日期时间

LocalDateTime currentDateTime = LocalDateTime.now();

自定义日期时间

//2018-07-19T17:20:21
LocalDateTime customDateTime = LocalDateTime.of(2018, 7, 19, 17, 20, 21);

日期时间计算

//向后推算
//返回指定年后的日期时间
LocalDateTime.plusYears(long years);
//返回指定月后的日期时间
LocalDateTime.plusMonths(long months);
//返回指定周后的日期时间
LocalDateTime.plusWeeks(long weeks);
//返回指定日后的日期时间
LocalDateTime.plusDays(long days);
//返回指定小时后的日期时间
LocalDateTime.plusHours(long hours);
//返回指定分钟后的日期时间
LocalDateTime.plusMinutes(long minutes);
//返回指定秒后的日期时间
LocalDateTime.plusSeconds(long seconds);

//向前推算
//返回指定年之前的日期时间
LocalDateTime.minYears(long years);
//返回指定月之前的日期时间
LocalDateTime.minMonths(long months);
//返回指定周之前的日期时间
LocalDateTime.minWeeks(long weeks);
//返回指定日之前的日期时间
LocalDateTime.minDays(long days);
//返回指定小时之前的日期时间
LocalDateTime.minHours(long hours);
//返回指定分钟之前的日期时间
LocalDateTime.minMinutes(long minutes);
//返回指定秒之前的日期时间
LocalDateTime.minSeconds(long seconds);

日期格式化

DateTimeFormatter formmater = DateTimeFormatter.ofPattern("yyyy/MM/dd E HH:mm:ss");

面向对象的三大特征

1. 封装
2. 继承
3. 多态性

继承

从其他类继承数据成员和方法的类称为子类或派生类
被子类从中继承的类称为超类或基类

单级继承：单个子类派生现有超类的功能
多级继承：子类继承其他子类的属性
分层继承：一个或多个子类继承自一个超类

继承也可以使用抽象类来实现
抽象类虽然不能实例化，但是可以使用extends关键字由其他类继承
但是，当抽象类被子类继承后，子类必须实现抽象类中定义的所有抽象方法，或者将子类也声明为抽象类

方法的重载

唯一确定方法：变量名相同，参数列表不同

public void add(int valA) {}
//变量名相同、参数列表不同时重载
public int add(int valB) {}			//不够成重载
public void add() {}
public void add(int valA, int valB) {}
public int add(double valA) {}

构造函数

1. 构造函数必须与类名相同
2. 构造函数没有返回值
3. 构造函数可以重载
4. 构造函数只能通过new调用

在抽象类中定义抽象方法

public void drwa();
public void draw() {};
public abstract void draw();	//正确
public void draw;

在子类构造函数中调用父类的构造函数

super

throw
throw关键字使得Java代码的正常控制流终止，并且停止后续语句的执行，将异常传给catch块，由该块处理要抛出的异常类型

1. 用在方法体内，跟的是异常对象，用于在程序中主动抛出异常对象
2. 每次只能抛出一个确定的异常对象
3. throw关键字抛出的异常可以由方法体内的语句处理
4. 一旦执行throw语句，方法体中throw语句之后的语句就不会被执行

throws
指定方法可以抛出的异常类型

1. 用于方法声明中，跟的异常类名
2. throws关键字后可以跟着多个异常类名，用逗号隔开
3. throws关键字指定方法可抛出的异常类型，声明后方法不处理异常，由方法的调用者处理异常
4. throws表示异常的一种可能性，并不一定发生这些异常

Throwable类

Throwable类时Java中异常的基类

Throwable派生类

1. Exception
2. Error

检查到的异常

未检查到的异常

类型转换

//小范围转大范围不会造成数据丢失，大范围转小范围可能造成数据丢失
int --> long		//隐式转换
double --> float	//显示转换
int --> char 		//显示转换
short --> int 		//隐式转换

使用Pattern和Matcher类

处理SQL异常

Exeception 是检查到异常
错误代码：int getErrorCode():
错误消息：String getSQLState():
SQL状态：SQLException getNextExecption():

3.下列数组声明错误的是？
D

A. String arr[] = new String[4];
	arr[0] = "java";
	arr[3] = "data";
B. String arr[] = new String[] = {"java", "python", "data"};
C. String arr[] = {"java", "python", "data"};
D. String arr[] = new String[4] = {"java", "python", "data"};

4.关于动态多样性方法重写，错误的是？
D
A. final方法不能被重写
B. 子类中重写的方法，访问权限范围不能比超类中小
C. 重写方法的参数名可以不同
D. 重写方法的返回类型可以不同

5.关于对象类型转换的描述，错误的是？
D
A. 对象引用转换时必须具有层次结构关系，才能进行转换
B. 所有对象引用都可以转换为object类型
C. 派生类的对象引用可以转换为基类的类型
D. 基类的对象引用不能转换为派生类

6.下列那个选项可以读取硬盘上的文件数据？
C
A. FileWriter
B. ObjectOuptputStream
C. BufferedReader
D. 都满足不了要求