数据类型包括：
基本数据类型 :byte,short,int,long,double,float,char,boolean
引用数据类型：类、接口、枚举,数组
整数：
十进制、二进制、十六进制互相转化
把负整数转化成二进制：把对应的正整数转化成二进制,然后取反加一；
变量：
1. 局部变量在使用前一定要初始化或者赋值。
2. 变量分类：
局部变量－在方法中定义的变量。
实例变量–
静态变量－
Java的程序块可以定义在方法体内，类体内。程序块可以嵌套。在任何程序块内都可以声明变量。
程序块定义了一个作用域。
变量的作用域就是包含它，离它最近的程序块。
局部变量的可见性从声明之后到离开作用域之前都可见。
实例变量的可见性－实例方法中可见；静态方法中不可见。
局部变量在同一个作用域中不能有相同名称的变量；
局部变量可以和实例变量同名。
局部变量保存在栈中。
类型转化：
l 整型字面量赋值给byte,short的时候，如果值没有超出byte或者short的范围，自动转换，否则编译错误。对浮点型字面量不适合。
l 整型和浮点型之间的转化。整型可以自动转化成浮点型。
自动提升原则：
对a op b
1. 如果a,b中有一个是double型，那么另一个自动提升为double。
2. 如果a,b中有一个float型，那么另一个自动提升为float。
3. 如果a,b中有一个为int型，那么另一个自动提升为int。
4. 如果a,b不是double,float,int，那么a,b自动提升为int。
数组
l 数组变量存放在栈中，数组空间在堆中。
l 数组的长度。arrayName.length
l 数组是使用类来实现。
l 数组是引用类型。
l 数组中的元素会自动初始化。
逻辑运算符：
&和 &&的区别：
如果左边表达式的值为false,&&不会再计算右边表达式的值，整个表达式的值为false;
|和||的区别：
如果左边表达式的值为true,||不会再计算右边表达式的值，整个表达式的值为true;
1. 将一个int整数的各个字节颠倒形成一个新的int整数。
原来的int型整数：
| b3 | b2 | b1 | b0 | |||
|
|
|
|
| |||
新的int型整数：
| b0 | b1 | b2 | b3 |
2. 把十进制转化成十六进制。
属性：变量：实例变量，静态变量（类变量）
行为：方法
方法操作变量。方法用来实现类的功能。
类的成员：变量和方法
类的功能：方法
Math.rand()
type name (para-list) {
}
type:简单数据类型，数组，引用类型
name:动词，动名词组
param-list:以，分开的变量序列
参数传递：
简单类型的变量：按值传递－ copy。
构造函数：
1. 方法不能调用构造函数；构造函数可以调用方法。
2. 一个类的构造函数可以有多个。一个构造函数可以调用另外一个构造函数。
3. 不带参数的构造函数－缺省构造函数。当类中没有任何构造函数时，系统缺省生成不带参数的构造函数。
4. 构造函数的调用－ new构造函数。
5. 构造函数的匹配:首先匹配个数，然后匹配类型。类型完全相同或者符合自动类型转化的就通过，否则编译错误。
6. 构造函数不能继承。
this
1. 变量的隐藏：同名的局部变量隐藏了同名的实例变量。
2. 实现一个构造函数调用另外一个构造函数。
重载
方法名相同，参数不同的方法，叫重载方法。与返回类型无关。
1. 匹配方法名
2. 匹配参数－ 先看参数个数，再看类型（完全匹配，自动转化后匹配）
在编译的时候就决定的。静态的。
对象传递按引用传递，引用按值传递。
数组的传递等同于对象的传递。
对象从方法返回的传递同上。
访问控制
private 缺省 protected public
类的成员的可见性
|
存取修饰
|
同一类别
|
同一包
|
子类别
|
全局
|
|
private
|
OK
|
|
|
|
|
(default)
|
OK
|
OK
|
|
|
|
protected
|
OK
|
OK
|
OK
|
|
|
public
|
OK
|
OK
|
OK
|
OK
|
类的可见性
public:任何包中均可见。
缺省：同一包中可见。
class A {
int i;
void method(int i, A a) {
System.out.println(“i = ” + i);
System.out.println(“a.i = ” + a.i);
//a = new A();
i = 130;
a.i = 500;
}
public static void main(String[] args) {
A a = new A();
a.i = 200;
int i = 100;
a.method(i,a);
System.out.println(“a.i = ” + a.i);
}
}
类的成员：
变量：实例变量，静态变量
方法：实例方法，静态方法
静态变量：归类所有，所有对象共享静态变量。――――类变量
实例变量：归对象所有。每个对象都有一个实例变量的拷贝。
静态方法：
静态块：
静态块不能访问实例变量。
非静态块可以访问静态变量。
静态变量和静态块什么时候执行?
类在加载的时候初始化。只执行一次。
怎样访问静态变量和静态方法？
l 通过类名访问。 className.var/meth(…)
l 通过对象去访问 obj.var/meth(…
单一模式：在系统中只能产生一个类的实例。
final:
必须初始化
不能被修改。
内部类：
1. 内部类可以直接访问外部类的成员。不受访问控制符限制。
2. 外部类不可以直接访问内部类的成员。不受访问控制符限制。
3. 内部类可以声明在包围类的任何程序块中。
4. 当一个内部类定义在包围类的方法中时，只能访问该方法的final常量。
GC
垃圾收集器
不需要程序员手工做。
什么对象才能被回收？
当一个对象不存在对它的引用时。。。。。。
Finalize
动态栈：动态增长。
子类继承超类的变量和方法，但能否访问取决于访问控制符。但不继承构造函数。
super
l 调用超类的构造函数。必须位于第一行。超类中必须有对应的构造函数。
如果子类的构造函数中没有显式地调用超类中的构造函数，那么缺省调用超类中不带参数的构造函数。
l 调用超类的成员。受制于访问控制符。
替换原则：
超类的引用变量可以引用子类的对象。引用变量的类型决定了能访问哪些成员。
Is a / is a kondof
单继承：一个子类只能有一个超类。
类的层次：构造函数的调用。变量的初始化顺序：变量声明时的初始化优先于构造函数中变量的初始化。
覆盖方法：
1. 子类中的方法和超类中的方法名称相同;
2. 参数相同（个数相同和类型相同）。
3. 子类中的方法的返回类型和超类中的方法的返回类型兼容:
u 两者完全相同；
u 子类中的方法的返回类型是超类中的方法返回类型的子类。
4. 如果超类中的方法是static,或者private,或者final那么一定不是覆盖方法。
5. 子类中的方法的可见性大于等于超类中的方法的可见性。
构造函数不能被覆盖.
类的成员的可见性:
|
| private | 缺省(包可见性) | protected | public |
| 自己的类 | Y | Y | Y | Y |
| 同一包中的非子类 |
| y | y | Y |
| 同一包中的子类 |
| y | y | y |
| 不同包中的非子类 |
| n | n | y |
| 不同包中的子类 |
| n | y | y |
设计一个通用类，在类中定义一些通用的方法。通用的方法提供了标准的接口。然后子类去具体实现通用类中的通用方法。
－同一个接口（方法），有多种实现。实现了多态性。
具体类：实例化
抽象类：不能实例化
抽象方法：没有方法体的方法。
抽象类可以包含抽象方法，也可以不包含抽象方法。
如果一个类中有抽线方法，那么该类一定是抽象类。
如果子类没有实现抽象类中的抽象方法，那么子类必须是抽象类。
abstract class Sort {
public abstract void sort(int [] data);
}
class quickSort extends Sort {
public void sort(int [] data){
…….
}
}
final:
定义常量
阻止方法覆盖
阻止类的继承－阻止方法覆盖。
Object
l equals
缺省实现：如果两个对象的引用相等，则两个对象相等。
反射性：对称传递一致性 x.equals(null) => false;
instanceof :
o instanceof type: o是否是type的实例或者type的超类的实例。
l hashCode:
一致性
如果a.equals(b) == true,那么a.hashCode() == b.hashCode()
如果a.equals(b)！== true,那么a.hashCode()！== b.hashCode()
String:
String生成的字符串不允许改变。
字符串池。
给每个不同的字面量生成一个对象，放入字符串池中。
StringBuffer：生成的字符串可以改变。
String,StringBuffer是线程安全的。StringBuilder不是线程安全的。StringBuilder效率最高。
静态常量也可以导入。Import static java.lang.Math.PI;
要使用不同包中的类、接口、枚举、异常，必须首先导入。Java.lang可以不导入。
怎样解决冲突问题？
在同一个类中使用同名的类、接口。
1. 一个导入，另外一个使用全限定名称。
2. 都使用全限定名。
如果在一个类中导入另外一个包中的类，同时本包中也存在相同的类，那么不会产生冲突，优先使用导入的类。
程序中怎样使用已开发好的类？
l 使用.class文件。
l 使用打包的class文件。
bin> jar –cvf test.jar cn
加入到库中。Properties -> java build path->libraries->add external jars
接口
如果一个类没有把接口中的所有方法都实现，那么该类必须声明为抽象类。
接口可以继承接口可以多重继承。
接口中的成员的可见性。public,缺省=>public。
接口是一种引入类型，声明接口引用变量。接口变量可以引用实现了该接口的类的实例。
1. 覆盖Object中的 clone()方法。
2. 类要实现Cloneable接口。
3. 可以将Clone方法的可见性改为public。
4. 在clone（）方法中首先调用super.Clone()。
浅克隆：
Object.clone()的默认实现。只对简单变量和引用变量进行拷贝。
深克隆：
对包含的对象进行克隆。对String对象可以不深克隆，因为Stirng对象是不可改变的。
接口和抽象类
共性：定义一组通用的方法。
不同点：接口是比抽象类更高层次的抽象。
任何类都可以实现接口。抽象类只能由子类来继承，增加了耦合性。
抽象类中可以声明变量，但接口中只能声明常量。
抽象类中可以有具体方法，但接口中只能有抽象方法。
反射 reflection
JVM在运行时动态地分析、跟踪类和对象的能力。
对象在运行的过程中用Class对象来描述。
:一个类对应唯一一个Class对象。
Java中用2种方法处理异常：
1.在发生异常的地方直接处理；
2.将异常抛给调用者,让调用者处理。
(1)编译时异常:Java.lang.Exception
(2)运行期异常:Java.lang.RuntimeException
(3)错误:Java.lang.Error
Java.lang.Exception和Java.lang.Error继承自Java.lang.Throwable;
Java.lang.RuntimeException继承自Java.lang.Exception.
编译时异常：
程序正确，但因为外在的环境条件不满足引发。
例如：用户错误及I/O问题----程序试图打开一个并不存在的远程Socket端口。这不是程序本身的逻辑错误，而很可能是远程机器名字错误(用户拼写错误)。对商用软件系统，程序开发者必须考虑并处理这个问题。Java编译器强制要求处理这类异常，如果不捕获这类异常，程序将不能被编译。
运行期异常： 这意味着程序存在bug，如数组越界，0被除，入参不满足规范.....这类异常需要更改程序来避免，Java编译器强制要求处理这类异常。
错误：
一般很少见，也很难通过程序解决。它可能源于程序的bug，但一般更可能源于环境问题，如内存耗尽。错误在程序中无须处理，而有运行环境处理。
JVM从调用栈中招出一个与异常类型匹配的catch(…)。
完全匹配，子类异常可以匹配超类异常。
在嵌套异常捕获的时候，只要最近的捕获了，就不会再由外层的来捕获。
两类：
检查异常－处理
未检查异常－不处理 RuntimeException及其子类。
好处：
1. 每个方法可以向调用方抛异常。一层一层地抛出异常。与返回值的方法相比较。
2. 把错误处理代码和正常代码分开。
3. 异常是一个对象。可以从异常中把错误信息提出来。
尽量使用异常，少用返回值。
扫一扫
856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
