JKD8新特性
- 接口中可以定义有方法体的方法，如果是非静态必须用dafault修饰，静态就不用了
- 局部变量可以省去final
JKD7的新特性
- 二进制字面量
- 数字字面量下划线
- 泛型简化(菱形泛型)
- switch语句可以用字符串
- 异常的多个catch合并，每个用异常或｜
- try（）｛｝不用关流
JKD5的新特性
- 自动拆装箱
- 可变参数
- 静态导入
- 增强for循环
- 互斥锁
- 泛型
- 枚举
JAVA基础
逻辑与，短路与，逻辑或，短路或
&&左边为false右边不执行
｜｜左边为ture右边不执行
& |都执行
char型变量中能不能存贮一个中文汉字?
中文是Unicode,unicode编码占用两个字节，所以，char类型的变量也是占用2个字节
1个字节是8位
path,classpath
path配置的是exe
classpath配置的是class
如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次
熟悉Dos命令操作
cd进入，cd..退回，cd\退回根目录，cls清屏，md创建，rd删除目录，dle删除文件
java语言特点
开源，跨平台，面向对象
有垃圾回收机制
标识符
就是给类，接口，方法，变量，起名字的字符序列，
由大小写英文，数字$和_ 组成，不能使用关键字，数字不能开头
关键字
java语言赋予特殊含义的单词
保留：goto, const
常量
- 字面值常量：
整数常量
浮点数常量
字符常量
布尔常量
空常量 null
字符串常量
- 自定义常量：
用final修饰
进制
- JDK7新特性：
以0b开头表示二进制
以0开头表示八进制
以0x开头表示十六进制
- 其他进制到十进制的转换：
系数*基数的权次幂，结果相加。
- 十进制到其他进制的转换：
除以基数，取余数，结果反转。
- 快速转换：
二进制和十进制的相互转换 -- 8421码
二进制到八进制的简易方式 -- 3位组合
二进制到十六进制的简易方式 -- 4位组合
- 有符号数据的表示形式：原码、反码、补码
正数：
原码、反码、补码都一样，最高位表示符号位。
byte范围：-128 ~ 127
负数：
反码是对其原码逐位取反，但符号位除外。
补码是在其反码的末位加1。
- 理解强制类型转换的结果是怎么来的
注意是截取补码。
变量
Int I = 10 ;//I 就是变量, 变量就是用来储存数据的容器
数据类型
四类八种：
整数型
byte 1个字节(8位)
short 2个字节(16位)
int 4个字节(32位)
long 8个字节(64位)
浮点型
float 4个字节(32位)
double 8个字节(64位)
字符型
char 2个字节(16位) （一对单引号括起来的字符）
布尔型
boolean 1个字节
基本类型（四类八种）
整数byte--short--int--long 浮点float--double 字符char 布尔boolean
从小 到大byte--short--char--int--long--float--double
引用数据类型
数组，类，接口
掌握数据类型转换中的隐式转换和强制转换
运算符
- 算术运算符:
+ , - , * , / , % , ++ , --
注意：
前置++和后置++问题
int i = 10;
int j = i++ + i++ + i++; // j = ?
int a = 10;
a = a++; // 10
- 赋值运算符
=,+=,-=,*=,/=,%=
注意：
short s = 1;
s = s+1; // 可能损失精度
short s = 1;
s += 1; // 隐含一个强制类型转换
s = (short)(s + 1);
- 比较(关系或条件)运算符
==,!=,>,>=,<,<=
- 逻辑运算符
&,|,^,!,&&,||
- 位运算符
&,|,^,~ ,>>,>>>,<<
- 三目(元)运算符
(关系表达式) ? 表达式1 : 表达式2;
流程控制语句
- 顺序结构
自上而下
- 选择结构
if语句
if(){}
switch语句:
执行流程：
1. 先挨个匹配每一个case，匹配不上才走default
2. 结束，遇到break，或者执行到右方大括号
3. break可以省略，最好不要省略，容易出现case穿透
- 循环结构
for
while
do...while
do while至少执行一次循环体
for.while要先判断条件是否成立
for可以将变量及早释放
方法
实现某功能的代码块
方法之间是平级关系
方法调用才会执行
二维数组格式
- int[][] arr = new int[3][2].
- 2,int[][]arr = new[3][].
- 3,int[][]arr = {{1,2,3},{1,2,3},{2,3,3,4}};
最大长方度length - 1,长度length
java语言能否跨平台
各个平台安装对应的jvm
Jre包括jdk
jre:jvm+类库
jdk:jre+java开发工具
永久：JAVA_HOME=%directory%\Java\jdk path=%JAVA_HOME%\bin
临时:set path=%path%;
面向对象
功能
StringBuilder反转
Collections排序
Arrays排序
jdk中哪些类是不能继承的
String,Integer...包装类
带包的类的编译运行
编译javac -d . HelloWorld.java，运行java包名.HelloWorld
构造方法和和一般方法的区别
方法名与类名相同，没有返回值类型，连void也没有，没有返回值return;
构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次
什么时候使用构造函数呢？
分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内
一般函数，是对象创建后，需要调用才执行，可以被调用多次
构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload
4个权限修饰符
private:本类，默认:同一个包下（子类和无关类）
protected:不同包下(子类)
public:不同包下（无关类）
默认:
成员(实例)变量和局部变量区别
1在类位置不同
2在内存中的的位置不同
3生命周期不同
4初始化值 不同
成员变量和静态变量的区别
1.所属 成员是对象，静态是类
2.内存 成员是堆，静态是方法区
3.生命周期
4.调用
思想特点
是一种更符合我们思想习惯的思想
可以将复杂的事情简单化
将程序员从执行者变成了指挥者
类与对象
类：是一组相关的属性和行为的集合
构造方法 -- 构造器
成员变量 -- 属性、字段、域
成员方法
对象：是该类事物的具体体现
面向对象三大特性
封装
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
private关键字：
修饰成员变量
修饰成员方法
private修饰的成员只可以在本类中访问
this关键字
当前对象的引用,谁来调用我，我就代表谁
static关键字
随着类的加载面加载
优先于对象的存在
被类的所有对象共享
静态只能访问静态
（只能修饰成员变量，不能修饰局部变量）
注意：
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法，静态只能访问静态
代码块：
a:局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
b:构造代码块 (初始化块)
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
c:静态代码块
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
一般用于加载驱动（JDBC）
执行顺序：
静态代码块 --> 构造代码块 --> 构造方法
其中静态代码块只加载一次，构造代码块和构造方法每次创建对象都会执行。
继承
好处：
a:提高了代码的复用性
b:提高了代码的维护性
c:让类与类之间产生了关系，是多态的前提
特点：
java支持单继承，不支持多继承，但支持多层继承 -- 避免多继承的调用不明确
注意：
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
c:不要为了部分功能而去继承，体现"is a"的关系。
super关键字：
代表父类的存储空间标识。(可以理解为父类的引用)
类与类，接口与接口
A：类与类：只能是单继承。
B：接口与接口：可以是单继承，也可以是多继承。
C：类与接口：可以是单实现，也可以是多实现
java中只支持单继承，可以多层继承，接口可以多继承，也可以在继承的同时实现。（相同的是继承，不同的是实现）
abstract与哪些关键字不能共存为什么
private：私有的方法是不可见的，无法被复写
final：被final修饰的方法是最终方法，无法被复写
static：被static修饰的方法，要随类加载到方法区，由于抽象方法没有方法体所以不能加载
static的特点
随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名所调用。
静态方法只能访问静态成员，非静态方法既可以访问静态也可访问非静态
静态方法中不可以定义this、super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this；
Super和this
- this区分成员变量和局部变量重名，代表当前对象引用，谁调用我我就代表谁，super代表当前父类的引用
- super和this关键字可以在构造方法中共存
- super(有参或无参);和this(有参或无参);却不可以在构造方法中共存，因为它们都放在构造方法的第一行
- 一句话 this可以调用本类的也可以调用父类的(构造方法除外)
a:成员变量
this.变量 -- 本类的
super.变量 -- 父类的
b:构造方法
this(...) -- 本类的 -- 通过参数进行匹配的
super(...) -- 父类的
c:成员方法
this.方法名() -- 本类的
super.方法名() -- 父类的
重载与重写：
重载：java允许在一个类中，多个方法拥有相同的名字，但在名字相同的同时，必须有不同的参数，这就是重载。与返回值类型无关。
重写：
在子类中，方法声明(修饰符,返回值,方法名,参数列表)相同的情况。
注意事项：
a:父类中私有方法是不能被重写
b:子类重写父类的方法不能缩小父类的访问权限，不能抛出比父类更多的异常。
c:静态只能重写静态。（类的特点）
子父类中构造方法的用法：
A:子类的初始化过程中，首先会去执行父类的初始化动作。
因为子类的构造方法中默认有一个super()。
为什么?子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。
所以，子类的初始化过程中，会先执行父类的初始化。
B:如果父类没有无参构造方法
a:使用super调用父类的带参构造。推荐方式。
b:使用this调用本身的其他构造。
final,finally,finallized
final修饰类不能被继承，修饰方法不能被重写，修饰变量是一个常量只能赋值一次。finally是try语句中的一个语句，不能单独使用被它控制的语句一定会被执行用来释放资源。
finallized是一个方法，当垃圾回收器不存在对该对象更多引用时，被GC(garbage collection)调用回收垃圾
使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的
多态：
对象在不同时刻表现出来的不同状态。（父类子对象）
多态的前提
A:要有继承或者实现关系。
B:要有方法的重写/实现。
C:要有父类引用或者父接口引用指向子类对象。
多态有三种体现形式
类多态
抽象类多态
接口多态
特点： 只有在非静态方法时编译看父类运行看子类
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。 -- 编译期只看语法
Fu f = new Zi();
f.show();
因为方法存在着重写，而变量没有
好处：
可以提高代码的扩展性和可维护性。
弊端：
父类(接口)引用不能使用子类特有功能。 -- 向下转型
抽象类：
抽取出相同相象的，（看不懂的）
如果多个类中存在相同的方法声明，而方法体不一样，我们就可以只提取方法声明。
如果一个方法只有方法声明，没有方法体，那么这个方法必须用抽象修饰。
而一个类中如果有抽象方法，这个类必须定义为抽象类。
抽象类的特点
A:抽象类和抽象方法必须使用abstract修饰
B:抽象类不能被实例化
C:抽象类有构造方法，用于子类实例化使用
D:如果一个类是抽象类，那么，继承它的子类
F: 没有方法体
要么是抽象类。
要么重写所有抽象方法。
抽象类的成员特点
A:成员变量 可以变量，也可以是常量
B:构造方法 有构造方法
C:成员方法 可以有抽象方法，也可以有非抽象方法（全是抽象方法或者非抽象方法都是可以的）
abstract不能和哪些关键字共存
final -- 不能重写
private -- 子类不能访问
static -- 调用出问题
抽象类与普通类的唯一区别就是不能创建实例对象
接口：
如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种更抽象的表示形式：接口。
规则的体现。
接口的特点：
A:接口不能被实例化。
B:一个类如果实现了接口：
要么是抽象类。
要么实现接口中的所有方法。
接口的成员特点：
A:成员变量 只能是常量。默认修饰符 public static final
B:成员方法 只能是抽象方法。默认修饰符 public abstract
接口的思想特点：
A:对外暴露的规则
B:是功能的扩展
C:降低耦合度
耦合：类与类的关系
内聚：类自己完成某件事情的能力
高内聚，低耦合。
D:接口可以多实现。 -- 弥补了java单继承的局限性。还不会出现调用不明确。
JDK8以后新特性：
接口可以定义实现的方法了，如果是非静态的，要加default修饰，如果是静态可以不用default修饰。
抽象类与接口的区别
A:成员特点:
抽象类:
成员变量:
可以是变量,可以是常量.
构造方法:
有构造方法,用来对父类数据进行初始化.
成员方法:
可以有抽象方法 -- 要求子类做某些事情
可以有非抽象方法 -- 供子类继承.
接口:
成员变量:
全部都是常量.默认修饰符: public static final
成员方法:
全部都是抽象方法.默认修饰符: public abstract
B:关系特点:
类与类:
继承关系,只能单继承,但是可以多层继承.
类与接口:
实现关系.可以单实现, 可以多实现.
还可以在继承一个类的同时实现多个接口.
接口与接口:
继承关系, 可以单继承也可以多继承.
C:设计理念的区别:
抽象类定义的是系统的共性内容,体现的是 is a 的关系.
接口定义的是系统的扩展功能, 体现的是 like a 的关系.
内部类；
一个类定义在了另一个类里面，里面这个类就是内部类。
访问特点：
1:内部类可以直接访问外部类成员，包括私有
2:外部类要想访问内部类成员，必须创建对象。
内部类分类：
1:成员位置
private 安全
static 方便调用
格式：外部类名.内部类名 变量名 = new 外部类名.内部类名();
2:局部位置
定义在方法中。
局部内部类访问局部变量必须加final修饰。延迟生命周期。(JDK8之后可以不必手动加了)
匿名内部类:
没有名字的局部内部类。适合在调用一次的时候使用，可以当做参数传递
格式：
new 接口名或者抽象类名 () {
// 实现接口或抽象类的方法
// 可以有自己的方法（但是我们一般不这么用）
};
本质：匿名内部类实际上是实现了接口（或者继承了抽象类）的匿名子类对象。
理解上：其实是把定义子类（实现类）并重写方法，然后创建子类（实现类）对象这些操作放到了一起完成，一个格式而已。
API
学类，学功能，维护类之间的关系
Object
public boolean equals(Object obj)
比较两个对象，默认是比较地址值，一般我们会重写，实现具体属性的比较
public final Class<?> getClass()
返回对象所属类的字节码文件
public int hashCode()
返回一个int的哈希值，默认根据地址值算出来的，一般重写根据具体的属性值返回。
public String toString()
默认是全路径类名+@+地址值的十六进制表示形式。重写之后返回一些有意义的值。
public final void wait()
线程等待
public final void notify()
随机唤醒单个线程
public final void notifyAll()
唤醒所有线程
protected void finalize() -- 配置释放资源
final
finally -- 资源释放
Math
public static int abs(int a)
public static double ceil(double a) -- 向上取整
public static double floor(double a) -- 向下取整
public static long round(double a) -- 四舍五入
public static double random() -- 随机数
public static double sqrt(double a) -- 正平方根
Scanner
public int nextInt()
public String nextLine()
注意问题：
先int后String -- String获取不到，"\r\n"
String
构造方法：
1) String()
2) String(byte[] bys)
3) String(byte[] bys, int start, int length)
4) String(char[] chs)
5) String(char[] chs, int start, int length)
6) String(String str)
7) String s = "abc";
成员方法：
判断
equals(Object obj)
equalsIgnoreCase(String str)
contains(String s)
startsWith(String str)
endsWith(String str)
isEmpty() -- "" 与 null 区分开
获取
int length()
char charAt(int index)
int indexOf(char ch)
int indexOf(char ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(String str)
String subString(int start)
String subString(int start, int end) -- 左闭右开
练习：
1、给定一个字符串常量，统计该串中有大写字母、小写字母、数字各有多少个。
2、查找子串在大串中出现的次数，例如"hanbasdnbafllgnbahjnbakqqqqlnbaxnbai"中有多少"nba"?
转换
byte[] getBytes()
char[] toCharArray()
static String copyValueOf(char[] chs)
staitc String valueOf(int i)
String toUpperCase()
String toLowerCase()
String concat(String str)
其他功能
替换
String replace(String old, String new) -- 原串替换
String replaceAll(String regex, String new) -- 正则替换
切割
String[] split(String regex)
String trim()
int compareTo(String str)
字符串常量池的面试题
String s1 = "a";
String s2 = "b";
String s5 = "ab";
String s3 = "a" + "b";
String s4 = s1 + s2;
总结 String 17 个方法
首尾中空加判断
截长取位取元素
大小拼串转数组
除空切换正字典
1首startsWith
2尾endsWith
3中contains
4空isEmpty
5加判断equals
6截长substring
7取位indexOf，lastIndexOf
8取元素charAt
9，10大小toUpperCase，toLowerCase
11拼串concat
12取数组toCharArray
13除空trim
14切split
15换replaceFirst，replace，replaceAll
16正matches
17字典compareTo
int和String互转
1.int-->String String.ValueOf();
2. + "";
String-->int Integer.ParseInt();
StringBuffer -- 可变的字符序列
public int length()
public StringBuffer append(String str) -- 拼接
public StringBuffer insert(int offset,String str)
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
public StringBuffer replace(int start,int end,String str)
public StringBuffer reverse() -- 反转
public String substring(int start)
public String substring(int start,int end)
String和StringBuffer区别
String是不可变的字符序列,StringBuffer是可变的字符序列
String是引用数据类型，当作参数传递相当于基本数据类型，不会影响其值
String是final类所以不能继承
StringBuffer是安全的1.0(长度16),StringBuilder是不安全的1.5
Integer -- 基本数据类型的包装类
Integer与String类型的互换
int -- String
String.valueOf(int i)
Integer.toString(int i)
String -- int
Integer.parseInt(String str)
JDK1.5新特性：
自动装箱
自动拆箱
面试题：byte常量池
-128 ~ 127
Byte b1 = 100; // 保存到常量池
Byte b2 = 100;
Long lo1 = 120L;
Long lo2 = 120L;
Random
public int nextInt()
public int nextInt(int n) -- [0-n)之间的随机数
System
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) -- 理解
public static void exit(int status) -- 退出jvm
public static long currentTimeMillis() -- 测试程序运行时间
public static Properties getProperties() -- 了解系统属性
BigInteger
构造方法：
public BigInteger(String val)
成员方法：
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)
BigDecimal
构造方法
public BigDecimal(String val) -- 解决浮点数参与运算会损失精度
成员方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
Date
与字符串之间的互换：
SimpleDateFormat
public final String format(Date date) -- 格式化
public Date parse(String source) -- 解析
Calendar
public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)
public final void set(int year,int month,int date)
正则表达式
正则表达式的分割功能
public String[] split(String regex)
正则表达式的替换功能
public String replaceAll(String regex,String replacement)
正则表达式的获取功能
Pattern模式对象和Matcher匹配器对象的结合使用
典型调用顺序：
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
//boolean b = m.matches();
Matcher匹配器
public boolean find()
public String group()
==和equals区别
==基本数据是比较值,引用地址值,
equals没有重写object跟==一样,重写后比较的是属性值
Collection
数组和集合的区别
1、存储类型不同
数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
集合只能存储引用数据类型(对象)集合中也可以存储基本,数据类型,但是在存储的时候会自动装箱变成对象
2、长度不同
数组长度是固定的,不能自动增长
集合的长度的是可变的,可以根据元素的增加而增长
List
元素是有序的，元素可以重复。因为该集合体系有索引。
ArrayList:底层的数据结构使用的是数组结构。特点：查询修改快。但是增删稍慢。线程不同步。
因为底层采用数组的数据结构,而数组中的元素在堆内存中是连续分配的,而且有索引,所以查询快,增删稍慢
在使用迭代器遍历元素时,不能再使用集合的方法操作集合中的元素
调用集合的contains()或remove()方法时底层会调用equals方法,如果存入集合的对象没有实现equals(),
则调用Object的equals()方法
ListIterator
LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询修改慢。线程不同步。
栈 先进后出
堆 先进先出
Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
Set
元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
- HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
- LinkedHashSet
- TreeSet：可以对Set集合中的元素进行排序。
两种排序方式：一定要考虑清楚什么是主要条件，什么是次要条件
自定义排序:元素需要实现Comparable接口，重写compareTo方法。return int;
比较器排序: 创建一个比较器(实现Comparator接口,重写compare方法),在创建TreeSet集合时将比较器传递给集合. return int;
Map
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
- Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk0.效率低。
Properties
Properties是Hashtable的子类,是一个Map,存放的是键值对,一般用于项目的配置文件,配置文件中键和值的类型都为String类型
setProperty(String key,String value)向Properties中存入键值对
getProperty(String key)根据键获取值
public Enumeration<String> stringPropertyNames()以String的形式获取所有的键,并封装成Enumeration对象,之后进行遍历
load(InputStream inStream) 将字节输入流inStream所关联的文件中的值加载到Properties对象中
store(OutputStream out, String comments) 将Properties对象中的内容写入到out流所关联的文件中,comments为说明信息
- HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.效率高。
- TreeMap：底层是二叉树数据结构。不同步。可以用于给map集合中的键进行排序。
和Set很像。其实，Set底层就是使用了Map集合
map集合的两种取出方式:
Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。
HashMap和Hashtable的区别
Hashtable(注意t是小写的)：JDK1.0以后的，线程安全，效率低。不能存null值和null键。
HashMap: JDK1.2以后的，线程不安全的，效率高。可以存null值和null键。
（加一句：）这两个类也有共同点，他们都是双列集合，底层都是哈希算法。
泛型
好处：
1、提高安全性（把运行期异常转移到编译期）
2、不用强转了，省去强转的麻烦
格式：
<> <>中的数据类型必须是引用数据类型
注意事项：
前后泛型必须一致，或者后边的泛型可以不写（1.7的新特性菱形泛型）ArrayList<String> list = new ArrayList<String>();
泛型和增强for都是JDK1.5的新特性
泛型的由来：
以前的集合能存的是Object类型的数据，这样什么类型的数据都可以存进集合了，但是好多时候我们要做类型转换，这样就不安全。而泛型就是来解决这个问题的
分类：
非静态方法：
1、泛型可以与类的泛型一致，这样不用定义自己的泛型 public void show(T t) { }
2、泛型与类的泛型不一致，需要定义自己的泛型 public <V> void method(V v) { }
静态方法：
格式：
public static <B> void function(B b){ }
必须定义自己的泛型，为什么？
因为静态成员是随着类的加载而加载的，类加载的时候，对象还没有创建
泛型接口（了解）：
格式：在接口名后边加泛型即可
实现方式：
1、用普通类来实现class Demo1 implements Smoke<Student> { }较常用
2、用泛型类来实现class Test<T> implements Somke<T> { }
泛型高级之通配符（了解）：
<?>任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E固定上边界（向下限定），E及其子类
? super E固定下边界（向上限定），E及其父类
泛型练习
编写一个泛型方法,实现指定位置数组元素的交换
编写一个泛型方法,接收一个任意数组,并颠倒数组中的所有元素
注意:只有对象类型才能作为泛型方法的实际参数
在泛型中可以同时有多个类型
public <K,V> V getValue(K key) return { return map.get(key)}
案例:
package com.heima.generic;
//自定义泛型练习
public class ArraysUtil {
//编写一个泛形方法，实现指定位置数组元素的交换
public static <T> void exchange(T[] t,int index1,int index2){
T temp = t[index1];
t[index1] = t[index2];
t[index2] = temp;
}
//编写一个泛形方法，接收一个任意数组，并颠倒数组中的所有元素
public static <T> void reverse(T[] t){
int startIndex = 0;
int endIndex = t.length -1;
while(startIndex<endIndex){
T temp = t[startIndex];
t[startIndex] = t[endIndex];
t[endIndex] = temp;
startIndex++;
endIndex--;
}
}
}
遍历方式
数组 length属性
字符串length();方法
集合
list.size(),list.get();
Iterator
ListIterator
for( : )
普通for size();（操作元素要减减或是倒着遍历）
迭代器 （用ListInterator自身的方法操作元素）
增强for（不能删除元素）
Thread
进程和线程
(1)进程是正在执行的程序
(2)线程是进程中一个独立的控制单元(执行路径)（一个程序可同时一时间执行多个线程）
(3)进程中至少有一个线程,对于JVM,启动时至少有两个线程:JVM的主线程和JVM的垃圾回收线程
程序-->线程-->进程
多线程(多线程并行和并发的区别)
(1)并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU，同时进行)
｜--比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
(2)并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。（同时访问）
｜--如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
多线程(两种方式的区别以及两种实现方式的过程)
(1)查看源码的区别:
* a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
* b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空,
不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
(2)继承Thread
* 好处是:可以直接使用Thread类中的方法,代码简单
* 弊端是:如果已经有了父类,就不能用这种方法
用类名调用 Demo d = new Demo(); d.start();
this.name();
super(name);
Thread.currentThread().getName()
(3)实现Runnable接口
* 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
* 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
Demo d = new Demo()
Thread t1 = new Thread(d);
t1.start();
(4)start开启线程并运行run方法
run 仅仅是对象调用方法没用运行线程
wait()和sleep()的区别
(1)wait是Object类中的方法，sleep是Thread类中的方法
(2)sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
(3)wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
(4)sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
休眠线程、守护线程、加入线程、礼让线程
(1)休眠线程: sleep 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
(2)守护线程:设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
(3)加入线程:join 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
(4)礼让线程:yield让出cpu
同步代码块,同步方法,静态同步方法的区别?以及什么时候使用同步?
当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
(1).多线程操作共享数据
(2).有多条语句在操作共享数据
(3).要使用同一个锁
1. 同步代码块可以使用任意对象作为锁对象
2. 同步方法的锁为this,
3. 静态同步方法的锁为所在类的字节码对象(类名.class)
什么是死锁?
在多线程中，各自想得到对方的锁，缰持住了。
不要嵌套
说一下你所学过的线程安全的类?
(1)看源码：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
(2)Vector是线程安全的,ArrayList是线程不安全的
(3)StringBuffer是线程安全的,StringBuilder是线程不安全的
(4)Hashtable是线程安全的,HashMap是线程不安全的
说一下你对线程间的通信的理解?（两个或多个线程交替执行）
(1)什么时候需要通信
* 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
* 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
(2)怎么通信
* 如果希望线程等待, 就调用wait()
* 如果希望唤醒等待的线程, 就调用notify();
* 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
(3)多个线程通信的问题
* notify()方法是随机唤醒一个线程
* notifyAll()方法是唤醒所有线程
* JDK5之前无法唤醒指定的一个线程
* 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件
if notify
while notify
while notifyAll 1.5之前
reentrantlock 1.5新特性 new condition lock unlock singal
Runtime类,Timer类,互斥锁(*******ReentrantLock)?
线程组的概念?线程池的概念?
线程实现的第三种方式?-Callable
设计模式
1. 单例
1.饿汉式是空间换时间，懒汉式是时间换空间
2.在多线程访问时，懒汉式可能会创建多个对象
也叫: 延迟加载，非延迟加载
饿汉式
// 私有构造
private Student(){}
// 创建一个本类的唯一对象
private static Student s = new Student();
// 提供公共的访问方式返回这个对象
public static Student getInstance(){
return s;
}
懒汉式 -- 延迟加载
// 私有构造
private Student(){}
// 声明一个本类的唯一对象
private static Student s = null;
// 提供公共的访问方式返回这个对象
public static synchronized Student getInstance(){
if(s != null) {
s = new Student();
}
return s;
}
- 模版
- 装饰
BufferedReader(Reader)就是包装
- 工厂方法
- 简单工厂
- 适配器.
定义一个抽象类实现这个接口，然后继承这个抽象类
线程的5种状态
1.新建
2.就绪
3.运行
4.阻塞
5.死亡
网络编程三要素
ip,端口，协议
端口0-65535，0-1024是系统保留端口，
udp面向无连接，数据不安全，速度快
tcp面向连接，三次握手，数据安全，速度略低
IO
异常
Throwable
- Error
- Exception
RuntimeException
非RuntimeException
Error和RuntimeException，这些是需要改代码的。
RuntimeException也可以去做异常处理，但如果出现这样的异常，一般还是程序出了问题。
非RuntimeException 必须做异常处理：
1、声明异常 -- throws 异常类名
2、捕获异常 -- try...catch
常见异常
ArrayIndexOutOfBoundsException数组索引越界异常
NullPointerException空指针异常
ClassCastException类型转换异常
NumberFormatException数字格式异常
ConcurrentModificationException并发修改异常
Unsupported Encoding Exception不支持异常
EOFExceptions文件到了末尾异常
概念
* IO流用来处理设备之间的数据传输
* Java对数据的操作是通过流的方式
* Java用于操作流的类都在IO包中
* 流按流向分为两种：输入流，输出流。
* 流按操作类型分为两种：
* 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
* 字符流 : 字符流只能操作纯字符数据，比较方便。
InputStream/OutputStream
字节流InputStream/OutputStream
|--FileInputStream/FileOutputStream：文件字节流，用于文件的读写操作
|--BufferedInputStream/BufferedOutputStream：加缓冲区的字节流，用于提高效率
|--InputStream(字节输入流,字节流的抽象父类,抽象类不能直接创建对象,必须使用子类)
|--FileInputStream(文件字节输入流,就是以字节的形式读取文件内容)
|--read()每次读取一个字节(byte),但是返回值类型,为int类型,防止出现文件提前结束
|--read(byte[] b)每次读取多个字节,将内容放入字节数组b中
|--BufferedInputStream(字节输入缓冲流,其实就是一个包装类,创建对象时要接收一个InputStream,内部封装了一个1024*8的字节数组)
|--使用BufferedInputStream就不用再定义数组了
|--OutputStream(字节输出流,字节流的抽象父类)
|--FileOutputStream(文件字节输出流,就是以字节的形式将内容写入到文件中)
|--write()一次写出一个字节
|--write(byte[] b)将字节数组b里的内容写入到文件中
|--write(byte[] b, int off, int len)将字节数组b里的内容,从所以为off的位置开始,总共写len个
|--BufferedOutputStream(字节输出缓冲流,其实就是一个包装类,创建对象时要接收一个OutputStream,内部封装了一个1024*8的字节数组)
Reader/Writer
字符流Reader/Writer
|--FileReader/FileWriter：文件字符流，用于文本文件的读写操作
|--BufferedReader/BufferedWrite：加缓冲区的字符流，用于提高效率
转换流InputStreamReader/OutputStreamWriter：是字节流和字符流之间的桥梁
配置文件Properties
|--Reader(字符输入流,字符流的抽象父类,抽象类不能直接创建对象,必须使用子类)
|--FileReader(文件字符输入流,就是以字符的形式读取文件中的内容)
|--read()每次读取一个字符,即可以按照字符大小读取,返回值类型提升为int类型
|--read(char[] b)每次读取多个字符,将内容放入字符数组b中
|--BufferedReader(字符输入缓冲流,其实就是一个包装类,创建对象时要接收一个Reader,内部封装了一个1024*8的字符数组)
|--使用BufferedReader和BufferedWriter就不用再定义数组了
|--readLine()可以读取一行字符(不包含换行符号)
|--LineNumberReader是BufferedReader的子类, 具有相同的功能, 并且可以统计行号
|--getLineNumber()方法可以获取当前行号
|--setLineNumber()方法可以设置当前行号
|--Writer(字符输出流,字符流的抽象父类)
|--FileWriter(文件字符输出流,就是以字符的形式将内容写入到文件中)
|--write('a')/write("aaaa")可以写入单个字符或者写入字符串
|--write(char[] b, int off, int len)将字符数组b里的内容,从所以为off的位置开始,总共写len个
|--BufferedWriter(字符输出缓冲流,其实就是一个包装类,创建对象时要接收一个Writer,内部封装了一个1024*8的字符数组)
|--newLine()可以输出一个跨平台的换行符号"\r\n"
转换流(使用指定的码表读写字符)
|--InputStreamReader字节输入流到字符输入流的桥梁
|--OutputStreamWriter字符输出流到字节输出流的桥梁
其它流
SequenceInputStream序列流
序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
SequenceInputStream(InputStream in1,InputStream in2)
SequenceInputStream(Enumeration en)
ByteArrayOutputStream字节数组内存输出流
是将文件或键盘录入的数据写入到内存中的字节数组
ByteArrayInputStream字节数组内存输入流
是以字节的方式读取内存中的字节数组数据
创建此对象要传递一个字节数组
RandomAccessFile随机读写访问流
该流同时具有读和写的功能
seek(long pos)设置读取和写入的位置
ObjectOutputStream对象操作流,将对象写入到文件,要求对象所属的类实现Serializable接口,该接口里面没有内容,只是一个标记
writeObject()将对象写入文件
ObjectInputStream将上面存入到文件中的对象读取出来,因为存的时候所有对象是按照Object存入,所以取出来要进行强制类型转换
readObject()从文件读取一个对象出来
DataInputStream数据输入流,就是从文件读取特定类型的数据
readInt()从文件中读取一个int类型的数据
readLong()从文件读取一个long类型的数据
DataOutputStream数据输出流,向文件写出特定类型的数据
writeInt()向文件写入一个int类型的数据
writeLong()向文件写入一个long类型的数据
标准流
System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
System.setIn(InputStream)修改输入流
System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
System.setOut(PrintStream)修改输出流
第十种拷贝文件方法
System.setIn
System.setOut
键盘录入的两种方式
Scanner sc = new Scanner(System.in);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Close和flush区别
flush用来刷新缓冲区的,刷新后可以再次写出,即flush后流仍然可以使用
close用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出,即不能再使用该流
IO流的标准异常处理
Refelt
什么是反射
反射是拿到字节码文件，通过字节码文件反向得到字段getField，方法getMethod，构造方法getConustructor
什么时候加载类(类的加载时机)?
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
(1)创建类的实例
(2)访问类的静态变量，或者为静态变量赋值
(3)调用类的静态方法
(4)使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
(5)初始化某个类的子类
(6)直接使用java.exe命令来运行某个主类
类加载器的分类?
(1)Bootstrap ClassLoader （引导）根类加载器
* 也被称为引导类加载器，负责Java核心类的加载
* 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
(2)Extension ClassLoader 扩展类加载器
* 负责JRE的扩展目录中jar包的加载。
* 在JDK中JRE的lib目录下ext目录
(3)Sysetm ClassLoader 系统类加载器
* 负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径
获取字节码对象的三种方式?
(1)Object类的getClass()方法,判断两个对象是否是同一个字节码文件
｜-- Person p = new Person();
Class clazz3 = p.getClass();
(2)静态属性class,锁对象
｜-- Class clazz1 =类名.class 当作静态方法的锁对象
(3)Class类中静态方法forName(),读取配置文件
｜-- Class clazz = Class.forName(全类名)
反射中所用到的方法?
反射是拿到字节码文件，通过字节码文件反向得到字段getField，方法getMethod，构造方法getConustructor
(1)构造方法
|--获取:getConstructor()和getConstructors()
|--执行:newInstance()
(2)普通的成员方法
|--获取:getMethod()和getMethods()
|--执行:invoke()
(3)成员变量
|--非私有:getField()和getFields()
|--私有:getDeclaredField
|--访问私有的成员变量先执行:setAccessible(true),然后执行set方法
暴力反射?
可以获取字节码对象中的所有属性和方法,包括私有.对于私有的属性和方法要使用暴力反射,即使用getDeclaredXxx()方法获取,
然后再设置可以访问,即调用setAccessible(true)
泛型的擦除?
泛型只在编译期有效,在运行期会被擦除掉,生成.class文件之后泛型就没有了
谈谈你对动态代理的理解?
575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
