java基础知识总结
java在安卓的开发中是非常重要的，所以今天我总结了一下java的基础知识，当然，还有一些没有总结完，例如网络编程，io流等，将会在下一篇博文中写出。
概述
javac ：负责的是编译的部分
java ：负责运行的部分.会启动 jvm.加载运行时所需的类库,并对 class 文件进行执行
语法规则
数据类型
1 1 ）： 基本数据类型：byte（1个字节）、short（2）、int（4）、long（8）、float（4）、double（8）、char（2）、boolean。
1个字节占8位
2 2 ）： 引用数据 类型: 数组、类、接口。
运算符
+ - / % %:任何整数模 2 不是 0 就是 1，所以只要改变被模数就可以实现开关运算
&: 只有两边都为 true 结果是 true。否则就是 false。
|:只要两边都为 false 结果是 false，否则就是 true
& 和 && 区别： & ：无论左边结果是什么，右边都参与运算。
&&: 短路与，如果左边为 false，那么右边不参数与运算。| 和 || 区别：|：两边都运算。
|| ： 短路或，如果左边为 true，那么右边不参与运算。++X(–X)表示在使用x之前，先使x的值增（减）1
语句
If switch do while while for
当判断固定个数的值的时候，建议使用 switch，效率相对较高。
当判断数据范围，获取判断运算结果 boolean 类型时，需要使用 if。
当某些语句需要执行很多次时，就用循环结构，建议使用 for。因为 for 循环完毕，变量在内存中释放。
函数
重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的
类型不同，即可称之为该函数重载了。
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。
数据
// 二分查找法。必须有前提： 数组中的元素要有序。
public static int halfSeach_2(int[] arr,int key){
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)>>1; //(max+min)/2;
while(arr[mid]!=key){
if(key>arr[mid]){
min = mid + 1;
}
else if(key<arr[mid])
max = mid - 1;
if(max<min)
return -1;
mid = (max+min)>>1;
}
return mid;
}
java 分了 5 5 片内存。
1 ：寄存器。2 ：本地方法区。3 ：方法区。4 ：栈。5 ：堆。
栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
只要数据运算完成所在的区域结束，该数据就会被释放。后进先出。
堆：用于存储数组和对象，也就是 实体。啥是实体啊？就是用于封装多个数据的。
1 ：每一个实体都有内存首地址值。
2 ：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
3 ：垃圾回收机制。
面向对象
类
属性是用于存储数据的 ， 直接被访问，容易出现安全隐患 ， 所以，类中的属性通
常被私有化，并对外提供公共的访问方法。
这个方法一般有两个，规范写法：对于属性 xxx ，可以使用 setXXX(),getXXX() 对其进行操作
主函数的存在，仅为该类是否需要独立运行 ， 如果不需要，主函数是不用定义的。
主函数的解释：保证所在类的独立运行，是程序的入口，被 jvm 调用。
构造函数是在对象创建时，就被调用，用于初始化， 而且初始化动作只执行一次。
一般函数，是对象创建后，需要调用才执行，可以被调用多次。
封装
将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
this
用 this 调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初
始化动作一定要执行。 否则编译失败。
static
关键字，是一个修饰符 ， 用于修饰成员( ( 成员变量和成员函数) )
静态方法只能访问静态成员，不可以访问非静态成员。
静态方法中不能使用 this ，super 关键字。
成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。
静态代码块、构造代码块、构造函数同时存在时的执行顺序： 静态代码块 à 构造代码块 à 构造函数
单例设计模式
保证一个类在内存中的对象唯一性。
步骤：
1 1 ，因为创建对象都需要构造函数初始化 ，只要将本类中的构造函数私有化，其他程序就无法 再 创建
该类对象；
2 2 ，就在类中创建一个本类的对象 ；
3 3 ，定义一个方法，。 返回该对象，让其他程序可以通过方法就得到本类对象。 （作用：可控）
代码体现：
1 1 ，私有化构造函数 ；
2 2 ，创建私有并静态的本类对象 ；
3 3 ，定义公有并静态的方法，返回该对象
//饿汉式
class Single{
private Single(){} // 私有化构造函数。
private static Single s = new Single(); // 创建私有并静态的本类对象。
public static Single getInstance(){ // 定义公有并静态的方法，返回该对象。
return s;
}
}
//懒汉式:延迟加载方式。
class Single2{
private Single2(){}
private static Single2 s = null;
public static Single2 getInstance(){
if(s==null)
s = new Single2();
return s;
}
}
继承
java 中对于继承，java 只支持单继承。java 虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。
java 支持多重继承。A 继承 B B 继承 C C 继承 D。
子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。
super()和 和 this() 不可以同时出现的构造函数中。
在方法覆盖时，注意两点：
1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译
失败。
2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)
final
可以修饰类，方法，变量。不可以被继承、覆盖。
抽象类
抽象类的特点：
1 1 ： 抽象方法只能定义在 抽象类中 ， 抽象类和抽象方法必须由 t abstract 关键字修饰 （可以描述类和
） 方法，不可以描述变量） 。
2 2 ： 抽象方法只定义方法声明，并不定义方法实现。
3 3 ： 抽象类不可以被创建对象( ( 实例化) ) 。
4 4 ： 只有通过子类继承抽象类并覆盖了抽象类中的 所有 抽象方法后，该子类 才 可以实例化。否则，
该子类还是一个抽象类。
抽象类可以大一非抽象方法，抽象类中有构造函数。
接口
接口中有抽象方法，接口不可以实例化。 接口的子类必须实现了接口 中 所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
类与类之间存在着继承关系，类与接口中间存在的是 实现关系。
继承用 extends ； 实现用 implements
多态
体现： 父类引用或者接口的引用指向了自己的子类对象。 //Animal a = new Cat();
instanceof ;// 判断对象是否实现了指定的接口或继承了指定的类
Object
public boolean equals(Object obj){
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.age == p.age;
}
通常 equals ， toString ， hashCode ，在应用中都会被复写 ， 建立具体对象的特有的内容。
内部类
如果 A 类需要直接访问 B 类中的成员，而 B 类又需要建立 A 类的对象。这时,为了方便设计和访问，
直接将 A 类定义在 B 类中。就可以了。A 类就称为 内部类。内部类可以直接访问外部类中的成员。而外部类想要
访问内部类，必须要建立内部类的对象。
class Outer{
int num = 4;
class Inner {
void show(){
System.out.println("inner show run "+num);
}
}
public void method(){
Inner in = new Inner();//创建内部类的对象。
in.show();//调用内部类的方法。
}
}
匿名内部类：
当函数的参数是接口类型引用时，如果接口中的方法不超过 3 个。可以通过匿名内部类来完成参数的传递。
异常
通过 throws 关键字完成， 格式： throws 异常类名, , 异常类名
throw 用于抛出异常对象，后面跟的是异常对象；throw 用在函数内。
throws 用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws 用在函数上。运行时异常，其中 Exception 有一个特殊的子类 RuntimeException，以及 RuntimeException 的子类是运
行异常，也就说这个异常是编译时不被检查的异常。finally 很有用，只要用户关闭资源。无论是否发生异常，资源都必须进行关闭。
System.exit(0); //退出 jvm，只有这种情况 finally 不执行。
常见 异常 ：
1、脚标越界异常（IndexOutOfBoundsException）包括数组、字符串；
空指针异常（NullPointerException）
2、类型转换异常：ClassCastException
3、不支持操作异常；
包
常见的软件包:
java.lang : language java 的核心包，Object System String Throwable jdk1.2 版本后，该
包中的类自动被导入。java.awt : 定义的都是用于 java 图形界面开发的对象。
javax.swing: : 提供所有的 windows 桌面应用程序包括的控件, 比如： Frame , Dialog, Table, List
等等, , 就是 java 的图形界面库 。java.net : 用于 java 网络编程方面的对象都在该包中。
java.io : input output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写
入数据。java.util a : java 的工具包，时间对象 ， 集合框架。
java.applet : application+let 端 客户端 a java 小程序。 server+let – > servlet 端 服务端 java
小程序
多线程
创建线程：
方法1：
步骤：
1，定义类继承 Thread 类；
2，目的是复写 run 方法，将要让线程运行的代码都存储到 run 方法中；
3，通过创建 Thread 类的子类对象，创建线程对象；
4，调用线程的 start 方法，开启线程，并执行 run 方法。
方法2：
步骤：
1，定义类实现 Runnable 接口。
2，覆盖接口中的 run 方法（用于封装线程要运行的代码）。
3，通过 Thread 类创建线程对象；
4，将实现了 Runnable 接口的子类对象作为实际参数传递给 Thread 类中的构造函数。
为什么要传递呢？因为要让线程对象明确要运行的 run 方法所属的对象。
5，调用 Thread 对象的 start 方法。开启线程，并运行 Runnable 接口子类中的 run 方法。
Ticket t = new Ticket();
/*
直接创建 Ticket 对象，并不是创建线程对象。
因为创建对象只能通过 new Thread 类，或者 new Thread 类的子类才可以。
所以最终想要创建线程。既然没有了 Thread 类的子类，就只能用 Thread 类。
`*/`
Thread t1 = new Thread(t); //创建线程。
/*
只要将 t 作为 Thread 类的构造函数的实际参数传入即可完成线程对象和 t 之间的关联
为什么要将 t 传给 Thread 类的构造函数呢？其实就是为了明确线程要运行的代码 run 方法。
`*/`
t1.start();
同步
同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。
同步函数使用的锁是 this ， 静态同步函数的锁是 该类的字节码文件对象。
同步是隐示的锁操作，而 k Lock 对象是显示的锁操作，它的出现就替代了同步。
API
字符串
parseInt(string,radix); //将给定的数转成指定的基数进制；
在 在 5 jdk1.5 版本后，对基本数据类型对象包装类进行升级。在升级中，使用基本数据类型对象包装类可
以像使用基本数据类型一样，进行运算。
Integer i = new Integer(4); 5 //1.5 版本之前的写法；
Integer i = 4; // 自动装箱 ，5 1.5 版本后的写法；
i = i + 5;
//i 对象是不能直接和 5 相加的，其实底层先将 i 转成 int 类型，在和 5 相加。而转成 int 类型的操作是隐
式的。 自动拆箱：拆箱的原理就是 i.intValue();i+5 运算完是一个 int 整数。
集合框架
1：对象封装数据，对象多了也需要存储。 集合用于存储对象。
2：对象的个数确定可以使用数组，但是不确定怎么办？可以用集合。因为
List接口
List ： 有序( ( 元素存入集合的顺序和取出的顺序一致) ) ，元素都有索引。元素可以重复。
| | -- ArrayList ： 底层的数据结构 是数组, , 线程不同步 ，A At rrayList 了 替代了 Vector ， 查询元素的速
度非常快。
| | -- LinkedList ： 底层的数据结构是链表 ， 线程不同步 ， 增删元素的速度非常快。
| | -- Vector ： 底层的数据结构就是数组 ， 线程同步的 ，r Vector 无论查询和增删都巨慢。
对于 t list 集合，底层判断元素是否相同，其实用的是元素自身的 s equals 方法完成的。所以建议
元素都要复写 s equals
LinkedList ： 的特有方法。
addFirst();
addLast();
在 jdk1.6 以后。
offerFirst();
offerLast();
getFirst():获取链表中的第一个元素。如果链表为空，抛出 NoSuchElementException;
getLast();
在 jdk1.6 以后。
peekFirst();获取链表中的第一个元素。如果链表为空，返回 null。
peekLast();
removeFirst()：获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，抛出
NoSuchElementException
removeLast();
在 jdk1.6 以后。
pollFirst();获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，返回 null。
pollLast();
Set接口
当元素的 hashCode 值相同时，才继续判断元素的 equals 是否为 true。
TreeSet:
用于对 Set 集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。
如果元素不具备比较性，在运行时会发生 n ClassCastException 异常。
所以需要元素 实现 e Comparable 接口，强制让元素具备比较性， 复写 o compareTo 方法。
Map集合
– Hashtable ：底层是哈希表数据结构，是线程同步的。不可以存储 null 键，null 值。
– HashMap ：底层是哈希表数据结构，是线程不同步的。可以存储 null 键，null 值。替代了 Hashtable.
– TreeMap ：底层是二叉树结构，可以对 map 集合中的键进行指定顺序的排序。
把 把 p map 集合转成 t set 的方法
Set keySet();
Set entrySet(); //取的是键和值的映射关系。
取出 p map 集合中所有元素的方式一 ： keySet() 方法。
可以将 map 集合中的键都取出存放到 set 集合中。对 set 集合进行迭代。迭代完成，再通过 get 方法对获取
到的键进行值的获取。
Set keySet = map.keySet();
Iterator it = keySet.iterator();
w w hile(it.hasNext()) { {
Object key = it.next();
Object value = map.get(key);
System.out.println(key+":"+value);
} }
取出 p map 集合中所有元素的方式 二 ： entry Set() 方法。
Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()) {
Map.Entry me = (Map.Entry)it.next();
System.out.println(me. getKey()+"::::"+me. getValue());
使用集合的技巧：
看到 Array 就是数组结构，有角标，查询速度很快。
看到 link 就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()；
getFirst()；getLast()；
看到 hash 就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖
hashCode，equals 方法。
看到 tree 就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式 ：
一个是 Comparable ： 覆盖 o compareTo 方法 ；
一个是 Comparator ： 覆盖 e compare 方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
当存储的是一个元素时，就用 Collection。当存储对象之间存在着映射关系时，就使用 Map 集合。
保证唯一，就用 Set 。不保证唯一 ， 就用 List
双列集合 Map
Map map = new HashMap();
map.put("a", "aaa");
// 传统方式：必须掌握这种方式
Set entrys = map.entrySet(); // 1.获得所有的键值对 Entry 对象
iter = entrys.iterator(); // 2.迭代出所有的 entry
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
String key = (String) entry.getKey(); // 分别获得 key 和 value
String value = (String) entry.getValue();
System.out.println(key + "=" + value);
}
泛型
当类中的操作的引用数据类型不确定的时候，以前用的 t Object 来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。
class Tool<Q> {
private Q obj;
public void setObject(Q obj) {
this.obj = obj;
}
public Q getObject() {
return obj;
}
}
Data和日历类
将日期字符串转换成日期对象 ：是 使用的就是 DateFormat 方法中的 Date parse(String source)
public static void method(){
Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"
+getNum(c.get(Calendar.DAY_OF_MONTH))+"日"
+"星期"+getWeek(c.get(Calendar.DAY_OF_WEEK)));
}
public static String getNum(int num){
return num>9 ? num+"" : "0"+num;
}
public static String getWeek(int index){
/*
查表法：建立数据的对应关系.
最好：数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以
通过数组来作为表。
*/
String[] weeks = {"","日","一","二","三","四","五","六"};
return weeks[index];
}
