复习提纲 Java

第一章

java的特点：

• 简单，易于编写，有垃圾处理机制
• 与平台无关（Java虚拟机 : 在一个计算机上编译得到的字节码文件可以复制到任何一个安装了JRE的电脑上直接使用。字节码由JVM负责解释、运行，即Java虚拟机负责将字节码翻译为本地计算机的机器码，并将机器码交给本地操作系统来运行）
• 面向对象
• 多线程
• 安全
• 动态
  

Java的使用：
编写源文件 -->经Java编译器产生字节码–>Java解释器执行字节码文件

第二章

标识符：

1. 字母、数字、_、$
2. 第一个字符不为数字
3. 不能是关键字
4. 不能为true, false, null
   注意：Java语言使用Unicode字符集，因此Java所包含的字母包括汉字、日文中的片假名和平假名、朝鲜文、俄文等…

关键字：
abstract assert enum extends final finally goto
implements instanceof interface native strictfp super
synchronized transient volatile

基本数据类型：

数据类型	所占字节
boolean	1
byte	1（不存在byte型常量）
short	2（不存在short型常量）
int	4
long	8 (12L, -2058L)
char	2 (Java中一个字符占2个字节)
float	4（必须要有f/F跟在float型常量后面 123.456F, 存储时仅保留8位有效数字）
double	8

数据类型转换：
低级别–系统自动转换–>高级别
高级别–手动强制类型转换–>低级别

float a = 12.34;
int b = a;//出错
int c = (int) a;//强制类型转换，正确赋值

数组：
1.声明数组：名字+数据类型

float boy[];
char cat[][];

2.创建数组：为数组分配内存空间

boy = new float[10];
cat = new char [3][10];
int a[][] = new int[3][];//二维数组
a[0] = new int[8];
a[1] = new int[20];
a[2] = ne wint[3];

3.数组的初始化：创建数组时系统会默认赋零或null

float boy[] = {1.2F, 3, 48, 5.6f};
float boy[] = new float[4];
boy[0] = 1.2F;
boy[1] = 3;
boy[2] = 48;
boy[3] = 5.6F;
int a[][] = {{1},{1,2},{1,2,1},{1,3,3,1}};//创建一个数组该数组有4个元素，分别是长度为1，2，3，4的四个数组

4.数组比较：
System.out.println(a);//输出数组a指向的内存地址
a == b //判断a和b是否指向同一片内存
a.equals(b); // 效果和a== b相同
Arrays.equals(a,b); //判断数组a和b的内容是否相同
注意：对于char型数组 System.out.println(a);不会输出引用，而会输出内容

5.数组复制：
（1）arraycopy方法

public static void arraycopy(source, index1, desti, index2, length)

（2）copyOf和coptOfRange方法

public static double[] copyOf(source, newLength);
public static int[] copyOf(source, newLength);
......
public static double[] copyOfRange(source, from, to);//[from, to)
public static float[] copyOfRange(source, from, to);
......

6.数组的其他方法

方法	说明
Arrays.toString(array)	以字符串形式表示array
Arrays.sort(array, from, to)	对数组array进行[from, to)的升序排序
binarySearch(array, number)	在数组array中查找number值并返回其索引，否则返回负数

第三章

for语句：

数组与for语句：

for(int i=0;i<a.length;i++)//传统方式
	System.out,println(a[i]);
for(int i:a)//改进方式
	System.out,println(i);

第四章 类和对象

面向对象的特点	说明
封装	将数据和数据的操作封装在一起
继承	子类既可以继承父类的属性和方法又可以增添新的属性和方法
多态	(方法重载)向操作传递不同消息以便让对象根据相应消息来产生行为(方法重写)/同一操作被不同类型对象调用时可能产生不同的行为

1.类的声明：详见书P58

class People{
	
}
class 日本人{

}

2.实例变量和类变量 实例方法和类方法

class Dog{
	float x = 3.14;//实例变量
	static int y;//类变量\静态变量
	float max(float m ,float n){...}//实例方法
	static float jerry(){...}//类方法 静态方法
	static void show(String s){...}//类方法
}

1. 实例方法既能对类变量进行操作也能操作实例变量，类方法只能操作类变量
2. 实例方法可以调用实例方法和类方法，类方法只能调用类方法
3. 所有对象共享一个类变量
4. 类变量可以通过某个对象访问，也可以直接通过类名访问

3.this关键字
this.x this.y
this不能出现在类方法中

3.成员变量和局部变量 P57

4.方法重载
Java多态 = Overload+Override
Overload重载：一个类可以有多个方法具有相同的名字，不同的参数(参数个数或类型不同)

//与方法的返回类型参数的名字无关，只与参数类型和个数有关
float funcA(int a, int b);
int funcA(int a, char ch);
int funA(int a, int b[])

5.构造方法：可重载
一旦类中定义了构造方法，Java不提供默认的构造方法
如果成员变量在定义时没有初始化、构造函数也没有对它进行赋值，那么int 型为0， 浮点型为0.0，boolean型为false，引用型为null

6.析构方法 （不要求掌握）
java中有析构函数,但我们一般用不到它,因为java有自动内存回收机制,无需程序员来释放,也就不要担心内存泄露,只不过java中析构函数所采用的方式不是C++中的那样前加~号,在java中 对象析构时会调用void finalize()方法

7.纯代码块

8.调用顺序

9.对象的引用：
Java中 类的对象在堆中分配内存，对象的引用在栈中分配内存
空对象，没有引用指向它，Java提供自动的”垃圾收集“机制

10.对象的组合：

11.源代码编写顺序
package aaa.bbb.cc.dddd;
import java.io.XXX;
public class Example{
public static void main(String[] args){
…
}
}

12.类成员的访问权限
private 仅在类内部可访问
友好型 类内部和同包的类可访问
protected 类内部、同包的类和子类均可访问
public 均可以访问
注意：声明类时不能用private和protected修饰类

public class A{...}//正确
class B{...}//正确
protected class C{...}//错误定义类
private class C{...}//错误

13.基本数据类型的封装
自动装箱：把基本类型的值赋给基本数据类型对应的封装类对象

Integer a = 100;//装箱  必须保证类型一致
Integer b = new Integer(200);

自动拆箱：与装箱的过程相反

Integer a = new Integer(100);
int b = a;//拆箱 把封装类对象赋给基本类型

第五章 继承与接口

1.继承权限
子类和父类在同一个包里，继承父类的非private成员
子类和父类不在同一个包里，子类继承父类的protected和public成员，不能继承友好成员
注意：子类不继承父类的私有成员(虽然分配了相应内存空间)

2.方法重写：在子类中定义一个方法，这个方法的名字、参数个数、参数类型和父类的方法完全相同

3.super关键字
如果子类想使用被隐藏的方法，需调用super.funName(…);
子类调用父类构造函数 super(…);

4.final关键字(常量)
（1）final类：不允许有子类

final class A{...}

（2）final方法
不允许子类进行重写
（3）final变量(常量)
定义时必须初始化，定义后不能更改常量值

5.对象的上转型对象（多态的核心技术）

A a = new B();//A是父类 B是子类

上转型对象（1）不能操作子类新增的成员
（2）可以操作子类继承和隐藏的变量
（3）可以操作子类**继承和重写的方法**
可以将上转型对象强制转换为子类对象，这时该子类对象相当于正常子类对象

6.abstract类
（1）abstract类可以没有abstract方法
（2）abstract类不能创建对象
（3）非abstract类是另一个abstract类的子类，则必须重写父类中所有abstract方法
（4）abstract类只关心操作，不关心具体实现

7.abstract方法：只许声明，不许实现

abstract int min(int x, int y); //不能有方法体 

8.接口interface
接口定义 = 常量定义+abstract方法定义
（1）接口体只有常量和 abstract方法
（2）接口中所有成员都为public
（3）一个类只能继承一个类但可以实现多个接口

class Dog extends Animal implements Eatable, Sleepable{...};

（4）如果一个类实现了某接口，那么该类必须重写接口的所有abstract方法,并且重写的方法为public(继承/重写不能降低访问权限)

9.接口回调（与上转型对象类似，用于实现多态）

interface Eatable{
	void showFood();
}
class Dog implements Eatable{
	@Override
	void showFood(){
		System.out.println("肉类食物");
	}
}
public static void main(String [] args){
	Eatable e = new Dog();//接口回调第一步
	e.showFood();//接口回调第二步  通过接口变量调用类中重写的方法***多态
}

（1）
（2）
（3）

10.抽象类与接口的区别（简答题）书P135

11.基本数据类型和对象的区别（简答题）

第七章 Java常见异常类

Java常见异常类总结

泛型和集合框架

泛型可以是任何对象和接口，但不能是基本数据类型

class Cone<E>{//定义泛型类
	E bottom;
	int height;
	public Cone(E b){
		bottom = b;
	}
}
Circle c = new Circle(3.14);
Cone<Circle> onecone = new Cone<Circle>(c);//实现泛型类的具体化

list的通用方法：

linkedlist:

Map:

List、Set、Map的区别

可能考到的编程题：

1.文本文件的读写
2.模仿 Int/String类的编写 书P99

存在的疑问：

1. java.io包的File类是
   (A)字符流类 (B) 字节流类
   © 对象流类 (D) 非流类

2. Java中基本类型的封装类的使用

3. Java中catch，throw，try等工作机制
   throw 抛出错误
   throws 声明可能抛出的异常类型

public void loading() throws DangerException{
	...
	throw new DangerException();
	...
}

4. 模式匹配还没复习
   boolean str.matches(regex)
   String str.replaceAll(regex, replacement)
   String[] str.split(regex)

编程题练习：