构造代码块
作用：给对象进行初始化
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化；
而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的初始化内容。
{
代码
}
this代表他所在函数所属对象的引用。
简单说：那个对象在调this所在的函数，this就代表那个对象。
继承
1.子父类中的函数。
当子类出现和父类一摸一样的函数时，当子类对象调用该函数，会运行子类的内容，如同父类函数被覆盖一样。
这种情况是函数的另一个特性：重写（覆盖）
当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是
功能的内容却和父类不一致，这时只需使用覆盖特殊，保留父类的功能定义，并重写功能内容
2.子父类中的构造函数
在对子类对象进行初始化时，父类的构造函数也会运行，因为子类中的构造函数默认第一行有一条隐试的语句super();
super():会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
子类中至少会有一个构造函数会访问父类中的构造函数。
注意：super语句一定定义在子类构造函数的第一行。
抽象类的特点：
1.抽象方法一定定义在抽象类中；
2.抽象方法和抽象类都必须被abstract关键字修饰；
3.抽象类不可以用new创建对象，因为抽象方法没意义；
4.抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只5覆盖了部分抽象方法，那么子类还是一个抽象类。
模板方法
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，有该类的子类去完成
接口定义时，格式特点：
1.接口中常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
3.接口中的成员都是public的
4.接口：是不可以创建对象的，因为有抽象方法需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。
内部类：
1.内部类可以直接访问外部类的成员，包括私有
之所以可以访问外部类的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2.外部类要访问内部类，必须建立内部类对象。
3.访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 =（new）外部类对象.(new)内部类对象；
2. 当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的.
Test.function().method();
Test.function()：Test类中有一个静态的方法function
.method():function 这个方法运算后的结果是一个对象。
异常的处理
try
{
需要被检测的代码；
}
catch(异常类（Exception）,变量)
{
处理异常的代码；（处理方式）
}
finally
{
一定会执行的语句；
}
System.out.println(e.getMessage());
System.out.println(e.toString()); 异常名称：异常信息
e.printStackTrace(); 异常名称：异常信息，异常出现的位置。
抛出
throws使用在函数上 throw使用在函数内
throws后跟的是异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。
多线程 ：
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该储存功能就是run方法
例子：d.start();开启线程并执行该线程的run方法。
d.run(();仅仅是对象调用方法。而线程创建了，并没有运行。
runnable接口
将Runnable接口的子类对象传递给Thread类的构造函数
自定义的run方法所属的对象是Runnable接口的子类对象
所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象。
调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式的区别：
实现方式好处：避免了单继承的局限性。
在定义线程时：建立使用实现方式。
两种方式区别：
继承Thread：线程代码存放Thread子类run方法中。
实现Runnable:线程代码存在接口的子类的run方法。
线程安全问题产生的原因：
1，多个线程在操作共享的数据。
2，操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。
就会导致线程安全问题的产生。
解决思路；
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，
其他线程时不可以参与运算的。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。
在java中，用同步代码块就可以解决这个问题。
同步代码块的格式：
synchronized(对象)
{
需要被同步的代码 ；
}
同步的好处：解决了线程的安全问题。
同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。
同步的前提：同步中必须有多个线程并使用同一个锁。
//懒汉式
加入同步为了解决多线程安全问题。
加入双重判断是为了解决效率问题。
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
// -->0 -->1
s = new Single();
}
}
return s;
}
}
按照面向对象的思想对字符串进行功能分类。
* "abcd"
*
* 1,获取：
* 1.1 获取字符串中字符的个数(长度).
* int length();
* 1.2 根据位置获取字符。
* char charAt(int index);
* 1.3 根据字符获取在字符串中的第一次出现的位置.
* int indexOf(int ch)
* int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
* int indexOf(String str);
* int indexOf(String str,int fromIndex);
* 根据字符串获取在字符串中的第一次出现的位置.
* int lastIndexOf(int ch)
* int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
* int lastIndexOf(String str);
* int lastIndexOf(String str,int fromIndex);
* 1.4 获取字符串中一部分字符串。也叫子串.
* String substring(int beginIndex, int endIndex)//包含begin 不包含end 。
* String substring(int beginIndex);
*
*
*
* 2，转换。
* 2.1 将字符串变成字符串数组(字符串的切割)
* String[] split(String regex):涉及到正则表达式.
* 2.2 将字符串变成字符数组。
* char[] toCharArray();
* 2.3 将字符串变成字节数组。
* byte[] getBytes();
* 2.4 将字符串中的字母转成大小写。
* String toUpperCase():大写
* String toLowerCase():小写
* 2.5 将字符串中的内容进行替换
* String replace(char oldch,char newch);
* String replace(String s1,String s2);
* 2.6 将字符串两端的空格去除。
* String trim();
* 2.7 将字符串进行连接 。
* String concat(string);
*
* 3，判断
* 3.1 两个字符串内容是否相同啊？
* boolean equals(Object obj);
* boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。
* 3.2 字符串中是否包含指定字符串？
* boolean contains(string str);
* 3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
* boolean startsWith(string);
* boolean endsWith(string);
集合：Collection
//创建集合容器
ArrayList al=new ArrayList();//对象中存储的都是对象的引用（地址）
Iterator it=al.iterator();//获取迭代器，用于取出集合中的元素
list ：元素是有序的，元素可以重复，因为该集合体系有索引
ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步
LinkedLIst:底层使用的是链表结构。特点：增删速度很快，查询稍慢。
（特有方法
* addFirst()
* addLast()
*
* getFirst()
* getLast()
* 获取元素，但是不删除元素
* removeFirst()
* removeLast()
* 获取元素，但是删除元素，如果集合中没有元素，会出现NoSuchElementException异常
替代方法JDK1.6
offerFirst()
offerLast()
peekFirst()
peekLast();
获取元素，但是不删除元素,如果集合中没有元素，会返回null
pollFirst()
pollLast()
获取元素，但是删除元素,如果集合中没有元素，会返回null
Vector：底层是数据结构。增删改查很慢，线程同步，被ArrayList替代了。
枚举是Vector特有的取出方式；枚举和迭代器很像，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了
set:元素是无序的（存入和取出顺序不一定一致），元素不可以重复。
HashSet：底层结构是哈希表。
HashSet保持元素唯一性：
是通过元素的两个方法，hashCodehe和equals来完成
如果元素的HashCode相同，才会判断equals是否为true.
如果元素的HashCode不同，不会调用equals.
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode,和equals方法
-------------------------------------------------------------------------------
集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就使用集合容器进行存储。
集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。
框架的顶层Collection接口：
Collection的常见方法：
1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):
2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();
3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。
4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！
5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。
-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。
List:特有的常见方法：有一个共性特点就是都可以操作角标。
1，添加
void add(index,element);
void add(index,collection);
2，删除；
Object remove(index):
3，修改：
Object set(index,element);
4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);
list集合是可以完成对元素的增删改查。
List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
LinkedList:
addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();
getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():
removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();
---------------------------------------------
Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。
|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。
if(this.hashCode()== obj.hashCode() && this.equals(obj))
哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。
2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。
注意：如果哈希值不同，是不需要判断equals。
replace
public StringBuilder replace(int start,
int end,String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。先将子字符串中的字符移除，然后将指定的 String 插入 start。（如果需要，序列将延长，以适应指定的字符串。）
参数：
start - 起始索引（包含）。
end - 结束索引（不包含）。
str - 将替换原有内容的字符串。
返回：
此对象。
public String replace(char oldChar,
char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
如果 oldChar 在此 String 对象表示的字符序列中没有出现，则返回对此 String 对象的引用。否则，创建一个新的 String 对象，它所表示的字符序列除了所有的 oldChar 都被替换为 newChar 之外，与此 String 对象表示的字符序列相同。
参数：
oldChar - 原字符。
newChar - 新字符。
返回：
一个从此字符串派生的字符串，它将此字符串中的所有 oldChar 替代为 newChar。