本文深入讲解Java中的关键概念，包括基本类型转换、接口与类的继承特性、内部类的使用方法、异常处理机制以及集合框架等内容，帮助读者理解Java语言的基础与高级特性。
常见的操作方法。例如：转换为本基本类型或其它基本类型的方法
eg. byteValue(),intValue()…;parseByte(String s),parseInt(String s)…
valueOf(各基本类型或字符串)的使用。ValueOf(str)是包装类的静态方法，作用等同于构造器。它会解析传入的参数，然后构造一个相同类型的包装类，并返回该包装类。
例子：原始类型à字符串 (new Integer(101)).toString()；String.valueOf(“101”)
字符串à（包装类）à原始类型 Integer.parseInt(“string”)；
(new Integer(“101”)).doubleValue()；Integer.valueOf(“101”).intValue()
2.socket 套接字
3.在JAVA中一个接口可以有多个父接口，用逗号隔开，而一个类只能有一个父类。子接口继承父接口中所有的常量和方法。
4.在接口中所有的方法都 是抽象的。
5.static和非static之间永远无法override!
6..System.exit();在Applet里面不允许调用.
7.super()［顶端］;this();这两个函数只能在构造函数里调用.
8..如何用this呢?请看:
class Outer{ int i;
class Inner{
class InnerInner{
void Test(){
Outer.this.i=1;
}
}
}
}
看见了吧,类名.this.变量名,可以引用到i,第一次看到吧,嘿嘿,孤陋寡闻.
9.切记：一个原文件不能有两个public类
切记：静态方法不能调用非静态方法。
10.1.byte,char,short默认转成int
2.byte->short->int->long->float->double
char^
这是默认可以转型的方向,反了必须要显式cast! 特别注意:long->float是默认的,别看long64,float32,嘿嘿
还有就是看得出来,char和 byte,short之间无法互相默认转换
11.不同类型的对象，坚决不能用EQUALS（）方法比较，不论什么情况，都不相等。但编译不出错。
12.is a是继承的关系（包括接口），has a是一个类对象作为另一个类的成员。
13.任何时刻都要注意静态方法中不能直接调用非静态方法
14.‘\u’后只能是四个字符，只能在单引号里放着。boolean类型不能强制转化为char类型
15.Object oa = new Object();
oa = new Float[20];/////////正确，因为Object是任何类的超类，“Object=任何对象”都正确。
16.String类用来表示那些创建后就不会再改变的字符串，它是immutable[ 不可改变的]的。
StringBuffer类用来表示内容可变的字符串，并提供了修改底层字符串的方法。
当我们进行字符拼接时，请使用StringBuffer类而非String类，因为前者将比后者快上百倍
17. Java八种基本数据类型
byte b; 1字节
short s; 2字节
int i; 4字节
long l; 8字节
char c; 2字节（C语言中是1字节）
float f; 4字节
double d; 8字节
boolean bool; false/true
18.new String()和new String(“”)都是申明一个新的空字符串，是空串不是null。
19.重载：同名不同参，和返回类型无关
覆盖：同名、同参、同返回（子类不能改变父类接口，不能降低可见性，不可改变返回类型）
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
20.try后catch可以没有或者若干个，finally可以有一个或者没有。
21.byte、 short 型在计算时会自动转换成int
eg. byte b=127;
byte c=126;
byte d=(byte)(b+c);//必需转换否则报错
System.out.print(d);
22.1），Java中，不加访问修饰符时，默认为包内可访问。（注：C#不同，它不加时默认为private）
2），子类继承父类时，除了private成员不继承外，其余的原样继承。
3），缺省型和protected型，包内可访问，但阻止包外的类访问
4），protected[保护]不阻止包外的类继承，缺省只能被相同包的子类继承
注意：很多同学都以为父类的protected能被子类所访问，实际上它不是被子类直接访问，而是先继承到子类中，子类对象再对其自身的protected的访问！
23.
接口中的变量默认为public static final，而不管你有没有写这些关键字
总结：
1.接口的所有方法默认都是public,abstract和non-static的
2.接口的所有变量默认都是public,static,final的.所以,接口的变量不能改值,在它的实现类里.
3.接口的实现类实现的方法必须和接口的方法抛出同样的异常,不许是子类,这和override不一样!同样,如果接口方法没有抛,实现方法也不能抛.
4.实现类实现的方法必须显式的声明成public,什么都不写都不行！
5.接口不能声明成final,要不它怎么被实现呢？
6.一个类实现两个接口,如果两个接口有相同的方法,实现类就实现这个方法,没问题的. //两个接口共有此方法
22.
1，静态变量为类及所以实例所共享
2，短路符 && ||
3，非短路符 & |
23.
内部类分为：成员内部类、局部内部类、静态内部类和匿名内部类。
1，成员内部类：作为外部类的一个成员存在与外部类的属性方法并列。 如：InsideOne就是一个成员内部类。
注意：
(1) 在内部类中可以直接访问外部类的么有属性，不会破坏封装性。
(2)内部类和外部类的实例允许命名冲突（相同的名字）。
(3)在内部内中访问实例变量要用this.属性名（或者直接用属性名）。在内部类中访问外部类的实例变量要用：外部类名.this.属性名。 （如果内部类和外部类没有同名变量，则可以直接用变量名访问外部类变量）
(4)在另一个类中要创建该内部类要先创建一个外部类的实例，然后再创建该成员内部类的实例。
如：Person p = new Person();
Person.Name n = p.new Name();
(5)成员内部类不可以有static成员，因为static属性是在类加裁的时候被首先创建，而在这时内部类还没被创建。
2，局部内部类：在外部类的方法中定义的内部类。如：
public class Person(){
private int age;
public void run(){
class Run{
}
}
}
类Run就是局部内部类。
注意：（1）局部内部类的定义和局部变量的定义一样，不用加限定符，其作用域是为本代码块。
（2）它可以访问外部类的实例变量，也可以访问外部类的局部变量，但是外部类的局部变量必须为final的。
（3）可以配合interface来使用来做到强制性的弱耦合。
（4）在另外的一个类的中不可以创建局部内部类的实例，只能在局部内部类中来创建。
3，静态内部类：也是定义在类的内部用static来修饰。如：
public class Person{
private int age;
static class Name{
}
}
Name便是一个static内部类。
注意：（1）静态内部类只能访问外部类的static成员。
（2）在其它的类中要创建一个static内部类的对象不用外部类的对象。
Person.Name n = new Person.Name();
4，匿名内部类：定义在类的内部并且没有类名。如：
public class Person{
private int age;
class{
//一个匿名内部类
}
}
基于继承的匿名内部类，语法如下：
new <匿名内部类要继承父类的对应构造器> {
//匿名内部类类体
};
基于实现接口的匿名内部类，语法如下：
new <接口名> {
//匿名内部类类体，实现接口中的所有方法
}
（1）匿名内部类中使用外面的变量要被声明成final的。
（2）匿名内部类对象初始化的代码可以写在其非静态块中
（3） 匿名内部类生成的.class文件是<外部类类名>$<n>.class n是该类的第几个匿名内部类。
各种内部类可用的修饰符
成员内部类
final、abstract、public、private、protected、static
静态内部类
final、abstract、public、private、protected
局部内部类
final、abstract
匿名内部类
不能对匿名内部类使用修饰符
注意：1）匿名内部类只能创建一次实例。它从属于局部内部类。所局部内部类的所有限制都对它有效。
2）匿名内部类是唯一一种没有构造方法的类。
3）匿名内部类可以实现接口的回调。
24.
集合中只能放对象，不能放变量。（不能放int，可以放Integer）
25.List有序可重复，Set无序不可重复
LinkedList链表，适合需要频繁进行插入和删除操作
ArrayList顺序表，适合随机快速访问
Vector［矢量，向量］和ArrayList相当，可以说都是可变数组，但是Vector支持同步，更安全。
HashSet和 TreeSet类似，后者要求将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的。HashSet和TreeSet不同步。
Map是一种把键对象和值对象进行关联的容器，键（key）不允许相同，值（value）可相同。
HashMap对键不按序存放，TreeMap则是对键按序存放。
Hashtable extends Dictionary<K,V> implements Map<K,V>, 此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。它不同步。
25.
线程在启动后，其调度是cup决定的，非程序员所能控制
26.static(静态)方法中不能有super 和this关键字
27.：%运算时，不看分母，无论分母是正活是负，一律取绝对《切记！》
System.out.println(-5 % -2);////In our case (-5 % -2) is equal to -(5 % 2) = -(1) = -1
System.out.println(-5 % 2);////(-5 % 2) is equal to -(5 % 2)=-1
System.out.println(5 % -2);////(5 % -2) is equal to (5%2)=1
27. double d=1.09; d=d++;//正确
int i = 1++;//错误，不可以直接对常数进行++（--）运算《切记》［输入自动报错］
28.
System.out.println(1.0/0.0);//infinity 《正数除0结果为无穷大》
29.
array的初始化。
int[] a = new int[5]{1,2,3,4,5}///正确
30.
native void m1(){}///错误《native:本机，本地的》
native void mode();///正确
31.
匿名内部类没有构造方法！Java隐式的调用其父类的构造方法！抽象类中可以有构造方法！接口中不能定义构造方法！
32.
static final int a=5;///static final声明的变量一律做常量，并且必须在声明的时候初始化
33.
char 和short不可以自动互相转换，无论怎么转换，都提示损失精度，因此输入时就自动报错。
34.
String中的函数trim（）只能去掉字符串头尾的空格！
35.
String s = " \"abcde\" "，输出结果是"abcde",在JAVA语言中，引号用（\"）表示。而且如果输入""abcde""会自动报错。 《切记》
36.
final标志的变量为常量。
37.
构造方法中能做的：1．给类变量（包括static）赋值2．定义局部非静态变量或常量构造方法中不能做的：1． 给类静态常量赋值2． 定义局部静态常量或变量任何非静态方法中都不能定义静态变量！构造函数也是
38.
System.out.println(Integer.toHexString(18));//======>>10 //interger type convert 0X(十六进制数) type
System.out.println(Integer.toString(16));//======>>16
39.
byte b = 19+12;///OK 结果为31,其自动转换成int 型
40.
int[] a = new int[]{1,2,3,4,5};///正确《不能 int[5] a = new int[]{1,2,3,4,5};///如果提供了数组初始化操作，则不能定义维表达式》 《《切记，易错点》》
41.
对于interface不能用super和this关键字，二者只能用于类。
42.
final 声明的常量必须被初始化，final 声明静的态常量必须在声明的时候初始化。
43.
线程的优先级用数字来表示，范围从1到10，一个线程的缺省优先级是5
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 10
Thread.NORM_PRIORITY = 5
44.
java里十进制转二进制输出：Integer.toBinaryString(intNumber)《注意》
45.
java里所有的wrapper［封装］ class都是final的。
static synchronized void m(){}///static 和 synchronized可以同时出现。
注意，Integer不是关键字，所以可以做标识符用。（即int integer=5;这是正确的。《易忽视》）
46.
一定要注意一个原文件中不能有两个public，否则编译时会提示“出现致命异常”
47.
Java程序中，不能在所有类之外定义全局变量，只能通过在一个类中定义公用、静态的变量来实现一个全局变量。 内部类和方法与变量一样，可以被继承。
48.
java中数组没有length()这个方法，有length的属性。String有有length()这个方法。
49.
// 局部变量不能和参数命名相同：
private int mm (int i ){
int k=10l;
}
50.
System.out.println(1+2+"3");//33
System.out.println("1"+2+3);//123
51.
最大正数是01111....1111
最小负数是1000....0000(-2147483648)
52.
三角函数：double d = Math.cos(Math.toRadians(42)); //toDegress()将弧度数转化成度）
53.
Java中所有的参数传递都是传值的。
（static方法不能覆盖，private方法也不能覆盖。Java视它们为被隐藏）
多态最重要的一点在于run-time binding。多态是面向对象程序设计的目标。
throws是异常的申明，它置于方法的定义处；throw是异常的掷出，它置于方法体内。
异常可分为可检测异常和非检测异常，调用申明为可检测异常的方法时必须捕获异常。
String类最重要的一点在于“不变性（immutable）”。它的意思是一旦String类产生了就不会再改变了，若试图改变它都会产生新的对象。
54.
s=new String(“abc”);s+=”def”;System.out.println(s);
s=new String(“abc”);s.concat(“def”);System.out.prinln(s);
前一程序打印为“abcdef”，后一程序打印为“abc”。区别是第一个程序又重新赋值给了s。而第二个程序中s.concat(“def”)只是产生了一个新的对象但没有赋给谁，但原来的s不变。
55.
eg. byteValue(),intValue()…;parseByte(String s),parseInt(String s)…
c．valueOf(各基本类型或字符串)的使用。ValueOf(str)是包装类的静态方法，作用等同于构造器。它会解析传入的参数，然后构造一个相同类型的包装类，并返回该包装类。
例子：原始类型à字符串 (new Integer(101)).toString()；String.valueOf(“101”)
字符串à（包装类）à原始类型 Integer.parseInt(“string”)；
(new Integer(“101”)).doubleValue()；Integer.valueOf(“101”).intValue()
56.
Math类：
a。ceil()方法。该方法返回类型为double，往单一的正坐标方向取最近的整数
b．floor()方法。该方法返回类型类double，取最靠近其负向的整数。
c．round()方法。它有两个重载版本：double和float，返回分别为long和int
57.
· Collection 类：
· Collection 它是一个基类的接口，对元素没有任何的限制，可以重复并且无序。
· List 从其名就知是有序的列表。它描述的是按顺序将对象放入其中。显然，后放入的元素有可能与先前放入的对象是相同的。所以，List是允许对象重复出现的有序列表。
· Set 其实就是数学上所说的集合，它不允许有重复的元素。其中可以有空集（即null对象）。Set中的元素不要求有序。
· Map 即映射，借助于key和value来描述对象的搜索。key域中要求唯一性（其实就是一个Set），value域可以允许有重复的元素（其实就是一个Collection）。另外注意：常见的HashMap是无序的，而TreeMap是有序的。
58.
switch(i)中的参数最高精度是int（或者short,byte,char），但不可是long，float,double
59.
◆is a & has a
is a 描述的是一个超类和一个子类的关系，也即是继承的关系。
has a 描述的是一个对象的部分是另一个对象，也即是组合的关系（或称为调用）。
60.
wait(),notify()属于object方法，并不是线程的方法
wait(),notify()必须出现在synchronized方法或块中，否则会出现异常。原因是因为wait()会释放对象锁，而锁必然是出现在同步方法或块中。另外，wait()同sleep()一样，也必须捕捉异常InterruptedException。
61.
由于char的取值范围和int的正取值范围相同，所以，整型字面量可以直接赋给char。但是要是明确将一个整型（int）变量直接赋给char变量则编译错误。
另外，int i=5;char c=’a’;c+=i;编译是通过的。结果为：f。
62.
//求模%
//求余只管左边的符号，右边不管。
//int a=-5;int b=-2;System.out.println(a%b); //-1
//int a=-5;int b=2;System.out.println(a%b) ;//-1
int a=5;int b=-2;System.out.println(a%b); //1
63.
移位
a．>> 首位的拷贝右移位。等同于有符号的除法。
b．>>> 零填充右移位。
c．<< 左移位。等同于有符号乘法，但是必须遵循整数的溢出原则。
d．>>32 >>>32任何移多少位都是移模32的余数。eg.移32位即不移。
64.
有关java排序问题
/**
* 運用Arrays.sort(..)方法對數據進行排序，真的很快
* 減少了程序員自已寫代碼
* 并且效率非常高
* 這種排序可以排序所有數值型，包括char
* 并且可以從可以指定排序的下標范圍:Arrays.sort(Array,3,6)
* 或者就用常用的整个数组排序Arrays.sort(arrayName)
*/
65.
Java中的构造方法：
构造方法的方法名与类名相同，且没有返回值
如果有一个名字为Customer的类，那么要创建该类的对象，必须使用new关键字调用构造方法。比如，Customer类会有以下3个构造方法：
public Customer() {
}
public Customer(String custname, String pwd) {
this.custname = custname;
this.pwd = pwd;
}
public Customer(String custname, String pwd, Integer age) {
this.custname = custname;
this.pwd = pwd;
this.age = age;
}
根据这个例子，总结构造方法的特征：
1.构造方法的名字必须与类名同名，大小写也必须完全一致。
2.构造方法可以使用四种权限修饰符修饰。
3.构造方法没有返回值类型，注意，连void也没有。
4.一个类的构造方法，可以有多个，主要靠参数区别。
5.构造方法的方法体可以写任何符合Java语法的语句，但是，构造方法大多数时候都是用来初始化数据成员的。
66.
(2) finalize方法
finalize()［完成，最后的］是一个特殊的方法，用来释放类的实例所占用的内存资源，它由垃圾收集器自动调用，直到类的对象的最后一个引用从内存中释放的时候被调用。
67.
读取文件
1．
import java.io.*;
import java.util.*;
public class E01_FileIntoList {
// Report all exceptions to console:
public static void main(String args[])
throws Exception {
LinkedList lines = new LinkedList();
BufferedReader in =
new BufferedReader(
new FileReader("E01_FileIntoList.java"));
String s;
while((s = in.readLine())!= null)
lines.add(s);
in.close();
ListIterator it =
lines.listIterator(lines.size());
while(it.hasPrevious())
System.out.println(it.previous());
}
}
68.
java。IO
mkdir( ) 创建一个文件目录（在原有目录上）单目录。
mkdirs() 即可是在原有目录上也可是全新多层次的目录
69.
FileInputStream and |FileOutputStreeam(实质是文件输入流（读入写出到屏幕）、输出流｛写入输出到硬盘｝)
70.
点评： 在Java中代码重用有两种可能的方式，即组合（“has a”关系）和继承（“is a”关系）。“has a”关系是通过定义类的属性的方式实现的；而“is a”关系是通过类继承实现的。
71.
构造函数与方法的区别：
构造函数一般用于初始化变量，它无返回值，名字必须与类的名字相同。构造函数分为有参数和无参数两种形式，默认的构造函数属于无参数形式，构造函数是在类加载时被执行的。
方法是可执行对象的行为，可以有返回值，如果没有返回类型则为void类型。调用方法需要首先建立实例，再通过 实例名.方法名() 调用。static声明静态方法，静态方法不需要实例化即可调用，调用方式为：类名.方法名
72
static int x[]= new int[15];//自动变量不能被static修饰,因此这是错误的
73。
二维数组的几种定义方法
C. int a[][] = new int[10][10];
D. int [][]a = new int[10][10];
E. int []a[] = new int[10][10];
74.
switch```case ``
在开关语句中，标号总是不被当做语句的一部分，标号的作用就是做为条件判断而已，一旦匹配成功，就执行其后的语句，一直遭遇break语句为止。（包括default语句在内）
nt x =2;
switch(x)
{
case 1:
{
System.out.println("1");
break;
}
case 2:
{
//第一次匹配后就不在匹配如果没有遇到break语句就会一直执行下去
}
case 3:
{
System.out.println("3");
//break;
}
default:
System.out.print("errov!");
}//因此这里会输出：3 errov!
75.
内部类不能与外部类同名。另外，当Ｂ继承Ａ时，Ａ中的构造函数是带参数的，Ｂ中缺省构造函数的函数体为空；而ＪＡＶＡ编译器会为空构造函数体自动添加语句“super();”调用父类构造函数，更进一步是调用父类的参数为空的构造函数。而父类中没有参数为空的构造函数。
子类继承父类时并不继承构造函数
76.
静态方法除了自己的参数外只能直接访问静态成员。访问非静态成员，必须先实例化本类的一个实例，再用实例名点取。
77.
英文的进制问题：《《注意问题》》Octal（八进制）， binary（ 二进制 ）， hexadecimal（ 十六进制 简写hex），Decimal （十进制）
78.
equals()方法判定引用值是否指向同一对象。而== 比较句柄，就是比较变量A,B的地址存放的东西即值，但是前提是它们的类型必须一致，会则输入时就会报错。
79.
实例变量在类的一个实例构造时完成初始化，而且在类的静态方法中不能直接访问类的非静态成员而只能访问类成员（像上题中一样），类的普通方法可以访问类的所有成员和方法，而静态方法只能访问类的静态成员和方法，因为静态方法属于类，而普通方法及成员变量属于类的实例，类方法（静态方法）不能使用属于某个不确定的类的实例的方法和变量，在静态方法里面没有隐含的this，而普通方法有。
eg。public class Person{
int arr[] = new int[10]; //非静态
public static void main(String a[]) {
System.out.println(arr[1]); //此为静态方法，如果被访问的是非静态方法则会报错，因此，前面需要改成静态的（static int arr[] = new int[10];）才能运行
}
80.
重载与重写
public class Parent {
public int addValue( int a, int b) {
int s;
s = a+b;
return s;
}
}
class Child extends Parent {
}
Which methods can be added into class Child?
A. int addValue( int a, int b ){// do something...}
B. public void addValue (){// do something...}
C. public int addValue( int a ){// do something...}
D. public int addValue( int a, int b )throws MyException {//do something...}
(bc)
题目：哪些方法可以加入类Child中。
此题涉及方法重载（overload），方法重写（override）以及类派生时方法重写的规则。方法重载的规则是：一、参数列表必须不同，个数的不同完全可以，如果个数相同则参数类型的不同不能引起歧意，例如int 和long,float和double就不能作为唯一的类型不同；二、返回值可以不同，但是不能是重载时唯一的不同点（这点和c++中不同，c++中返回类型必须一致）。方法重写发生在类继承时，子类可以重写一个父类中已有的方法，必须在返回类型和参数列表一样时才能说是重写，否则就是重载，java中方法重写的一个重要而且容易被忽略的规则是重写的方法的访问权限不能比被重写的方法的访问权限低！重写的另一个规则是重写的方法不能比被重写的方法抛弃(throws)更多种类的异常，其抛弃的异常只能少，或者是其子类，不能以抛弃异常的个数来判断种类，而应该是异常类层次结果上的种类。此题中答案a的错误就是重写的访问权限比被重写的方法的低，而b,c都属于重载，d的错误在于比被重写的方法抛弃了更多种类的异常。
}
79.
数据库设计分为以下6个设计阶段：需求分析阶段、概念设计阶段、逻辑设计阶段、物理设计阶段、实施阶段及数据库运行和维护阶段。
数组是一种对象。
形式参数可被视为local variable
声明抽象方法不可写出大括号（抽象方法没有方法体）
80.
short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。
81.
hashmap［非同步，没排序］和hashtable［同步的］的区别。
都属于map接口的类，实现了将惟一键映射到特定的值上。
hashmap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
hashtable 类似于 hashmap，但是不允许 null 键和 null 值。它也比 hashmap 慢，因为它是同步的。
82.
Heap［堆］和stack［栈］有什么区别。
栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。
堆是栈的一个组成元素
83.
接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。
扫一扫
861
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
