一、包
1、 package<top_pkg_name>[.<sub_pkg_mame>];
2、import导入包。可用“.* ”导入包中全部类。默认导入java.lang.*。
3、静态导入（Static Import):使用静态导入可以使被导入的所有静态变量和静态方法在当前类中直接可见，使用这些静态成员无需再给出他们的类名。
例如：
import static java.lang.Math.pow; public static void main(String[] args) { double d=pow(10,1); }
二、类、属性、构造器、成员方法的声明
类声明：<作用域> class <类名>{ <属性声明><构造函数声明><方法声明>}
方法：<方法作用域> <返回类型><方法名称>(<参数列表>){}
可变参数:（下面是一个关闭一个或多个流的函数）
public static void closeAll(Closeable... io){ for(Closeable temp:io){ try { if (null != temp) {
temp.close(); } } catch (Exception e) { } }
note:
1、构造方法与类名相同，没有返回值。构造方法也可以调用其他构造方法，用this实现，this的参数指明调用哪一个构造方法。
2、如果一个类没有构造器，那么虚拟机将自动给该类一个默认的构造器（无参构造）。如果在该类里面构造了带参数的构造器，那么虚拟机将提供默认构造方法，当然，也不能按照默认构造方式构建。
3、方法内的变量不能有static和访问权限（作用域）的关键字修饰，注意它们是局部变量。它们可以被final修饰。
三、运算符和优先级
乘除加减与数学算式中顺序的计算相同，有括号的优先计算
1、算术运算符与圆括号的优先级比较
|
由 高 到 低 |
|||
|
（） |
+，—（正，负号） |
*，/,% |
+,-(加，减号) |
|
|
同级 |
同级 |
同级 |
|
|
单目运算符 |
双目运算符 |
|
2、关系运算：
|
优先级 |
优先级相同（高） |
优先级相同（低） |
||||
|
关系运算符 |
＞ （大于） |
＞＝ （大于等于） |
＜ （小于） |
＜＝ （小于等于） |
＝＝ （等于） |
！＝ （不等于） |
3、逻辑运算符
|
优先级 |
由 高 到 低 |
||
|
逻辑运算符 |
!（逻辑“非”） |
&&（逻辑“与”） |
||（逻辑“或”） |
（1）同级运算看是“左结合”还是“右结合”，不同级看级的高低
（2)在关系运算符、算术运算符、赋值运算符、逻辑运算四者中，优先级从高到低依次为：！（逻辑“非”）、算术运算符、关系运算符、&&（与）、||（或）、赋值运算符
4、
位运算含义与功能
|
位运算符 |
含义和功能 |
优先级 |
|
~ |
按位求反 |
最高（单目） |
|
＜＜ |
左移 |
1 |
|
＞＞ |
右移 |
1 |
|
& |
按位与 |
2 |
|
＾ |
按位异或 |
3 |
|
｜ |
按位或 |
最低 |
注意：按位求反运算符为单目运算符，优先级别最高，结合性自右向左；其他为双目运算符，结合性自左向右。位运算对象只能是整型或者字符型数据。
注意：i++和++i
int j=0; for(int i=1; i<10; i++){ j=j++; } System.out.println(j);
上面的结果为0。先执行赋值，再执行+操作，当循环进入第一次，j被进行+1操作，但最后又因为未赋值前的值为0被赋值给j，所以每次循环j的值都没有改变，因此打印值为0.
下面：
1 public static void main(String[] args) { 2 int i=3; 3 i=i++ + i++; System.out.println(i); 4 i=3; 5 i=i++ + (++i); System.out.println(i); 6 i=3; 7 i=++i + i++; System.out.println(i); 8 i=3; 9 i=++i + (++i); System.out.println(i); 10 }
上面的结果为7， 8，8，9。
四、流程控制
if、else、switch、for、while、do、break、continue
注意项：
1、break借助标号可实现外层循环的中断（它可以不仅仅中断当前循环，标号为合法标识符）
例如：
public static void main(String[] args) { here: while(true){ for(int i=1; i<10; i++){ System.out.println(i); if(i==5) break here; } System.out.println("can't do"); } System.out.println("go to here"); }
2、continue:结束当前循环，循环语句内continue后的语句将不再执行。
3、switch(表达式){case : break; default:}
1)、表达式的类型：（1）、可以自动转换为int的基本类型的数据:byte ,short,char,int(long、double、float、boolean不可以）。（2）、字符串。（3）、枚举类型
2)、穿透现象，如果没有break;将会继续执行下一个case语句。
3)、default，最后剩余的情况
五、数据类型：
基本数据类型
|
|
类型 |
位数 |
默认值 |
|
逻辑型 |
Boolean |
1bit |
false |
|
文本型 |
Char |
16bit(2byte) |
'\u0000' |
|
整数型 |
Byte |
8bit(1byte) |
0 |
|
|
short |
16bit(2byte) |
0 |
|
|
int |
32bit(4byte) |
0 |
|
|
long |
64bit(8byte) |
0 |
|
浮点型 |
double |
64bit(8byte) |
0.0 |
|
|
foalt |
32bit(8byte) |
0.0 |
注意bit、byte、'\u0000'是怎么回事：
1、1byte=8bit，1bit是1位二进制数，boolean的大小为1bit，也就是只储存0或1，对应着false或true。
2、'\uxxxx'中\是转义字符，u是Unicode，后面跟一个十六进制数，通过这个十六进制数来指定一个字符
note:
1、自动置入/自动取出（Autoboxing/unboxing）（自动装箱、拆箱）：Java基本数据类型都有各自对应的包装类。
public static void main(String[] args) { Integer age=new Integer(20); Integer now=age+1;//引用类型于基本类型直接计算 System.out.println(now); } //Integer类构造器源码： public Integer(int value) { this.value = value; }
引用类型 (字符串、数组、类)
引用可以理解为C中的指针，但不能像C语言那样计算指针。在使用引用变量之前，必须为他分配实际的存储空间，用关键字new实现。
字符串
private void arr() { String s1="abcdefg"; String s2="abcd"; String s3="efg"; String s5="efg"; String s4=new String("abcdefg"); System.out.println(s1=="abc"+"defg"); System.out.println(s1==s2+s3); System.out.println(s4=="abc"+"defg"); } /* 结果： 第一条打印的是true，第二条是false，第三条返回的也是false。 首先，s1、s2、s3、s4都是常量池中的对象 第一条打印语句，"abc"+"defg"的结果为"abcdefg"，这个时候会返回常量池中"abcdefg"的对象，也就是s1引用的对象,所以返回的是true；第二条打印语句，虽然它们相加的结果也等于"abcdefg",但是它将会在池中再生成一个String对象，并返回这个对象。再看第3条打印语句，"abc"+"defg"返回的是s1引用的对象，s1是直接指向常量池的，而s4是new出的对象的引用，new出的对象存储在堆中（但字符串也是储存在常量池的）。因此返回的是false。同理：s4==s1也返回false。如果使用String重写Object的equals(),返回的将是true。 总结： 执行代码String s="abc"时，就会去找又没有对应内容的对象，如果有，返回池里的对象，如果没有，则生成一个对象，并将其返回（s3=s5）。如果加号两边不是字面值（字面值，被“”引起来的。第二条语句不是字面值，new出的也不是），那么将不会在池中查找是否存在，而是直接创建一个新的对象。对于String不使用new将会更节省空间，更简单。 String s="abc"在编译期就被确定了，而String s=new String("abc")是在运行 期。 */
数组类型
Java编程语言并没有提供多维数组，但可以创建数组的数组来实现多维数组。例如二维数组也可以这样定义
int a[][]=new int [3][4]; int b[]={1,2,3,4}; a[0]=b;
数组的for-each遍历
1 public static void main(String[] args) { 2 int sum=0; 3 int a[]={1,2,3,4,5}; 4 for(int i:a){ 5 sum+=i; 6 } 7 System.out.println(sum); 8 }
二维数组的遍历
private void arr() { int a[]={1,2,3}; int b[]=new int[]{1,2}; int arr[][]={a,b};//数组的数组,用一维数组构造二维数组 int a1[][]={{1,2,3,4},{3,4}}; int a2[][]=new int[][]{{1,2,3,4,5},{5,4}};//二维数组的第一个数组长度为5，第二个长度为2 int a3[][]=new int[2][3];//每个数组元素是一个长度为3的数组 for(int i=0; i<arr.length; i++){ for(int j=0; j<arr[i].length; j++) System.out.print(a1[i][j]); System.out.println(); } System.out.println(); for(int i=0; i<a2.length; i++){ for(int j=0; j<a2[i].length; j++) System.out.print(a2[i][j]); System.out.println(); } System.out.println(); for(int i[] : a1){//数组的数组，二维数组的for-each遍历 for(int k : i) System.out.print(k); System.out.println(); } }
数组的拷贝：System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
枚举类型
public enum Color{ Red,White,Blue; } for(Color c:Color.values()){ System.out.println(c); }
集合类型
接口：List、Set、Map
1、List：是有序的Collection，能够随机存取，元素可重复。
LinkedList
ArrayList
Vector
2、Set：元素不重复，最多只有一个null元素。
HashSet
LinkedHashSet
3、Map：提供key-value的映射。key值不重复。
HashMap
SortedMap
HashMap与Hashtable区别：（1）HashMap允许有空键值，非线程安全，效率高，Hashtable不允许为null;（2）HashMap方法containvalue和containKey对应Hashtable的contains;(3)Hashtable继承自Dictionary类，而HashMap是Map interface的一个实现。（4）Hashtable是同步的，HashMap不是同步的。
Java高级特性
访问控制：
Public(公共）：访问无限制。
Protected（保护）：因继承而生，同包内可访问，不同包的当前类的子类可访问，不同包的不是该类的子类不访问。
friendly（默认）：访问限于该包。
Private（私有）：访问限于该类。继承
1、子类能从父类中继承什么，不能继承什么？
能继承：
(1)父类中的所有public成员（包括成员变量与成员方法）
(2)父类中的所有protected成员（包括成员变量与成员方法）
(2.1)当子父同包时，子类继承的protected成员，可以让同包其他类来访问，类似缺省
(2.2)当子父不同包时，子类继承的protected成员，不可以让同包其他类来访问，类似私有
(3)父类中的所有缺省成员（包括成员变量与成员方法），当子类与父类同包时可以继承，不同包不能继承
不能继承：
(1)父类中的所有private成员（包括成员变量与成员方法）
(2)异包父类中的所有缺省成员（包括成员变量与成员方法）
2、子类与父类的构造方法是什么关系（构造方法能否继承）？
(1).当产生子类对象时，先默认调用父类无参构造方法（除非有特殊指定），然后调用子类构造方法
(2).在子类构造方法中可以使用super()来指明调用父类某个构造方法，super必须是子类构造方法中第一个可执行语句，并不意味着只能调用父类的一个构造，因为子类中可写多个构造，多次super()。
(3).子类不能继承父类的构造方法，更不存在覆盖的问题。
3、子类从父类中继承的方法在子类中能否被改写？
可以改写，叫方法重写或方法覆盖。
方法重载：方法名相同，参数列表不同，返回值类型可以不同。
方法覆盖（方法重写）：子类与父类之间的多态性，子类对父类的函数重新定义。子类中定义的某方法与父类有相同的名称和参数，称为重写（此时返回值类型必须相同，否则会报错）。1、如果方法被重写，新的方法会覆盖父类中原有的方法，可用super调用原有的方法。2、子类的访问修饰权限不能低于父类的。
多态：
（1）继承，（2）方法重写，（3）运型时根据实际创建的对象类型动态决定使用哪个方法。
向上转型：父类引用指向子类对象；向下转型：将父类的对象强制转换为子类的对象
抽象类：
1）关键字abstract定义； 实现：extends继承
2）抽象类：对一类类的抽象,一般包含抽象方法，使用abstract关键字来修饰
3）抽象类只能用来继承，不能直接产生抽象类对象，可以有构造方法（当某类共有常用）
4）一个类继承抽象类后，若不对抽象类中的抽象方法重写，则这个类仍是抽象类
5）抽象类中可以有非抽象方法，也可以没有任何方法；抽象类中若没有抽象方法，则不用重写
6）意义：将方法的设计与实现分离（接口也是，抽象的，都具有不唯一性）
接口
1）使用interface关键字来定义的一组抽象方法的总称。实现：implements 关键字
2）接口定义的属性为常量，相当于public static final
3）只有常量和抽象方法
4）可以有多个接口
note：（1）接口内的方法默认是抽象的public abstract，并且不可有普通方法；（2）类接入接口后必须重写方法或定义为抽象类
内部类
具有很好的分装性，内部类可以无限制的访问外部类的数据，包括私有属性和方法。并且可已被public、private、static等修饰。当一个类没有static修饰时，这个内部类就叫成员类。
成员内部类
静态内部类
匿名内部类
局部内部类
作用
1.内部类可以很好的实现隐藏。一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
2．内部类拥有外围类的所有元素的访问权限
3.可是实现多重继承
4.可以避免修改接口而实现同一个类中两种同名方法的调用。
关键字
this：指代当前对象。1、引用成员变量。可区分同名的局部变量。2、引用构造方法。必须是构造方法类的第一条可执行语句。
super：在子类对象内部直接指代其直接父类父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。继承构造时，只能是构造方法的第一条可执行语句，表示调用哪个构造方法。调用其属性不必是第一条语句。
static：用来声明成员属于类，而不是类的对象。static变量（类变量）可以被所有对象共享。可通过类名直接调用。静态变量（方法）的生命周期是整个程序。
final：修饰类，该类不能被继承（终态类，如String）。修饰方法，该方法不能被覆盖。修饰变量，该变量为常数。final维护着安全。
posted on
