Java小结

DOS命令(理解)
(1)切换盘符(掌握)
d: 回车
(2)显示某目录下的所有文件或者文件夹(掌握)
dir 回车
(3)创建文件夹
md 文件夹名称 回车
(4)删除文件夹
rd 文件夹名称 回车
(5)进入目录(掌握)
单级进入 cd 目录名称
多级进入 cd 目录名称1\目录名称2…
(6)回退目录(掌握)
单级回退 cd…
回退根目录 cd
(7)删除文件
del 文件名称
*.txt 可以表示多个文件名称
(8)清屏(掌握)
cls
(9)退出
exit
(10)扩展DOS命令
删除带内容的文件夹
rd /s 文件夹名称 会提示是否删除
rd /q /s 文件夹名称 直接删除
JDK,JRE,JVM(掌握)
(1)JVM
保证Java语言跨平台。针对不同的操心系统提供不同的JVM。

	问题：java语言是跨平台的吗?JVM是跨平台的吗?
(2)JRE
	java程序的运行环境。包括JVM和核心类库
(3)JDK
	java开发环境。包括JRE和开发工具(javac,java)

A:单行：//注释文字
B:多行：/* 注释文字 /
C:文档注释：/* 注释文字 */
标识符(掌握)
(1)标识符：给类，接口，方法或者变量起名字的符号
(2)组成规则：
A:英文字母大小写
B:数字
C:_和$
(3)注意事项：
A:不能以数字开头
B:不能是Java中的关键字
C:区分大小写
Student,student 这是两个名称
(4)常见命名方式：
A:包 其实就是文件夹,用于解决相同类名问题
全部小写
单级：com
多级：cn.itcast

	B:类或者接口
		一个单词：首字母大写
			Student,Person,Teacher
		多个单词：每个单词的首字母大写
			HelloWorld,MyName,NameDemo
	C:方法或者变量
		一个单词：全部小写
			name,age,show()
		多个单词：从第二个单词开始，每个单词首字母大写
			myName,showAllStudentNames()

	D:常量
		一个单词：全部大写
			AGE
	多个单词：每个单词都大写，用_连接
			STUDENT_MAX_AG

A:整数默认是int类型，浮点数默认是double类型

数据类型(掌握)
(1)数据类型分类
A:基本类型：4类8种
B:引用类型：类，接口，数组
(2)基本类型
A:整数 占用的内存空间
byte 1
short 2
int 4
long 8
B:浮点数
float 4
double 8
C:字符
char 2
D:布尔
boolean 1
整数默认是int类型，浮点数默认是double类型
Switch语句中的byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
if语句和switch语句的各自应用场景
A:if语句
可以对几个常量值进行判断
可以对表达式是boolean类型的进行判断
可以对一个数据范围进行判断
B:switch语句
适合几个常量值的判断(单选题)
for循环和while循环中的循环体可以一次不执行，do…while循环中循环体至少执行一次
a:可以相互等价转换，相互改写
b:当循环变量需要保留下来供以后计算，则使用while循环在循环体前面定义控制变量；否则建议优先使用for循环，提高程序运行效率；其次是while循环，最后是do…while循环
C:for循环适用于知道一定范围，while循环更常用于循环次数不一定
java中的内存分配
A:栈 存储局部变量
B:堆 new出来的
C:方法区
D:本地方法区
E:寄存器

java参数传递问题
基本类型：形式参数的改变不影响实际参数。
引用类型：形式参数的改变直接影响实际参数。
java中只有值传递。因为地址值也是一个值。

匿名对象
(1)匿名对象：没有名字的对象。是对象的简化书写方式。
(2)使用场景
A:调用方法，仅仅只调用一次
B:作为实际参数传递

static关键字
(1)是一个状态修饰符。静态的意思
(2)它可以修饰成员变量和成员方法
(3)特点：
A:随着类的加载而加载
B:优先于对象存在
C:被所有对象共享
D:可以通过类名调用
静态修饰的内容，可以通过类名调用，也可以通过对象名调用
(4)方法访问特点
A:普通成员方法
可以访问静态成员变量，非静态成员变量，静态成员方法，非静态成员方法
B:静态成员方法
只能访问静态成员变量，静态成员方法
简记：静态只能访问静态
注意：
静态中是不能有this的。
先进内存的不能访问后进内存的。反之可以。

静态成员变量和普通成员变量的区别
(1)所属不同
静态属于类的，称为类变量
非静态属于对象的，称为对象变量，实例变量
(2)内存空间不同
静态在方法区的静态区
非静态在堆内存
(3)生命周期不同
静态随着类的加载而加载，随着类的消失而消失
非静态随着对象的创建而存在，随着对象的消失而消失
(4)调用不同
静态可以通过类名调用，也可以通过对象名调用。建议通过类名调用
非静态只能通过对象名调用

代码块
局部代码块：在方法中。限定变量生命周期，及早释放，提高内存使用率
构造代码块：在类中方法外。把多个构造中的相同代码用一个构造代码块体现，每次创建对象都会自动调用。
静态代码块：在类中方法外，用static修饰。对类中的数据进行初始化。仅仅执行一次。
·执行顺序;执行过程：静态代码库 --> 构造代码块 --> 构造方法 --> 局部代码块

方法重写的注意事项：
A:父类私有方法不能被重写
B:子类重写方法的访问权限不能比父类的方法低
C:静态只能重写静态。(其实这算不上重写)

final关键字
特点：
A:修饰类 类不能被继承
B:修饰成员变量 变量变成了常量
C:修饰成员方法 方法不能被重写
A:final修饰局部变量
a:基本类型 值不能发生改变
b:引用类型 地址值不能发送改变，对象的内容是可以改变的
B:final的初始化时机
a:在定义时就赋值
b:在构造方法完毕前赋值

多态中的成员访问特点：
Fu f = new Zi();
A:成员变量
编译看左边，运行看左边
B:成员方法
编译看左边，运行看右边
C:静态方法
编译看左边，运行看左边

抽象类的成员特点：
A:成员变量
可以是变量，也可以是常量
B:构造方法
有。
不能实例化，有构造方法有什么意义呢?
用于子类访问父类数据的初始化。
C:成员方法
可以是抽象的，也可以是非抽象的

接口的成员特点
A:成员变量
只能是常量。
默认修饰符：public static final
B:成员方法
只能是抽象方法。
默认修饰符：public abstract

局部内部类:局部内部类访问局部变量，必须加final修饰

匿名内部类
A:没有名字的内部类
B:前提
存在一个类或者接口
C:格式
new 类名或者接口名() {
重写方法();
};
本质：是一个匿名子类对象
Eg:不用在定义一个新的类了。直接通过匿名内部类的格式就可以搞定

	interface Person {
		public abstract void show();
	}

	class PersonDemo {
		public void method(Person p) {
			p.show();
		}
	}

	PersonDemo pd = new PersonDemo();
	pd.method(new Person(){
		public void show(){...}
	});

==和equals()的区别?
A:==
基本类型：比较的是基本类型的值是否相同
引用类型：比较的是引用类型的地址值是否相同
B:equals()
只能比较引用类型，默认比较的是对象的地址值是否相同。
但是，可能被重写，一定要根据实际的情况来看。

字符串的特点
A:一旦被创建，值就不能发生改变（字符串的内容不能被更改，和字符串引用无关）
B:String s = new String(“hello”)和String s = "hello"的区别:前者创建两个对象，后者创建一个对象
StringBuffer是线程安全的可变字符串。
StringBuilder是线程不安全的可变字符串。
和StringBuffer的功能一样。就是效率高一些，但是不安全

常见的数据结构
A:栈
先进后出
B:队列
先进先出
C:数组
查询快，增删慢
D:链表
查询慢，增删快

Collection
|–List(元素有序，可重复)
|–ArrayList
底层数据结构是数组，查询快,增删慢
线程不安全,效率高
|–Vector
底层数据结构是数组，查询快,增删慢
线程安全,效率低
|–LinkedList
底层数据结构是链表，查询慢,增删快
线程不安全,效率高
|–Set(元素无序，唯一)
|–HashSet
底层数据结构是哈希表。
保证元素的唯一性?
依赖两个方法hashCode()和equals()。
|–LinkedHashSet
底层数据结构是哈希表和链表
由哈希表保证元素唯一
由链表保证元素有序
|–TreeSet
底层数据结构是二叉树(红黑树)
保证元素的唯一性?
根据比较的返回值是否是0
保证元素的排序?
自然排序
比较器排序

Collection，你准备使用谁?
元素唯一吗?
是：Set
要排序吗?
是：TreeSet
否：HashSet
不知道，就用HashSet
否：List
要安全吗?
要：Vector(其实也不用，有更好的方式，后面讲)
不要：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
不知道，就用ArrayList
不知道，就用ArrayList
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法hashCode()和equals()，根据情况选择是否自动重写
TreeXxx:底层数据结构是二叉树。有两种方案：自然排序，比较器排序。

增强for
for(元素的数据类型 变量名 : 数组或者Collection集合对象) {
把数组或者Collection集合对象一一赋值给变量名
}

Map的特点
是由键和值组成的。每一个元素是一个键值对，由两部分组成。
键唯一，值可以重复。
它的实现类的数据结构只针对键有效，跟值无关。

**Map和Collection的区别**
	A:Map双列集合，由键值对组成；键唯一，值可以重复；数据结构针对键有效
	B:Collection单列集合，有单个元素组成；Set唯一，List可重复；数据结构针对元素有效

HashMap和hashtable的区别
HashMap非同步，不安全，效率高
线程是否安全
是否允许null键和值

Collection和Collections的区别
A:Collection是单例集合的顶层接口，定义了单例集合的共性功能
B:Collections是针对集合进行操作的工具类

File是用来描述硬盘上的文件或者文件夹的
(2)File的构造方法
A:File file = new File(“d:\demo\a.txt”);
B:File file = new File(“d:\demo”,“a.txt”);
C:File file = new File(“d:\demo”);
File file2 = new File(file,“a.txt”);

throws和throw的区别
A:throws
方法声明上,后面跟的是类名,用逗号隔开，可以跟多个。表示可能有异常
B:throw
方法体中,后面跟的是对象名,只能跟一个。表示有一个异常产生

final,finally和finalize的区别?
final:修饰类，修饰成员变量，修饰成员方法
修饰类,类不能被继承
修饰成员变量，变量是常量
修饰成员方法，方法不能被重写
finally:被finally控制的代码永远会执行，用于释放资源。
注意事项：就是在执行到finally之前jvm退出了。
finalize:是Object类的方法，启动垃圾回收器，用于回收垃圾。
如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。
会执行。 前。 准确的说法：中间。

递归
A:一定要有出口，否则就是死递归
B:不要次数过多，否则内存溢出
C:构造方法不能递归使用

IO流
|–字节流
|–输入流 InputStream
|–FileInputStream
|–BufferedInputStream
|–输出流 OutputStream
|–FileOutputStream
|–BufferedOutputStream
|–字符流
|–输入流 Reader
|–FileReader
|–BufferedReader
|–输出流 Writer
|–FileWriter
|–BufferedWriter

复制文本文件：
	9种方案。
	字节流：4种
	字符流：5种
	建议使用字符流。并且用最后一种。
复制二进制流数据：
	4种方案。

高效字符流一次一个字符串
高效字符流一次一个字符数组
高效字符流一次一个字符
基本字符流一次一个字符数组
基本字符流一次一个字符
基本字节流一次读写一个字节
基本字节流一次读写一个字节数组
高效字节流一次读写一个字节
高效字节流一次读写一个字节数组

多线程的实现方案
A:继承Thread类
B:实现Runnable接口
C:实现Callable接口
线程默认优先级是5，优先级范围是1-10

解决线程安全问题
A：同步代码块
格式：
synchronized(对象) {
需要被同步的代码
}
对象可以是任意对象
B:同步方法
非静态 对象是this
静态 对象是当前类的字节码文件对象
start:启动线程，并自动调用run()方法
run:直接调用，仅仅是普通方法的调用
线程只能开启一次
线程的生命周期：新建 就绪 运行 阻塞 死亡