《JAVA学习指南》学习笔记

第二章声明和控制访问

1.源文件，包声明，导入语句规范（省略）。

2.格式化 main（）方法实例：

class Myclass{

public static void main{String whatever} { }

}

3.interface接口设计：接口=合约。规则：

a.所有接口方法隐含为公有的和抽象的。

b.接口中的变量必须是公有的，最终的，静态的，即只能是常量(只读值)，不能是实例变量。

public final static int LOW_VALUE =1;

c.JAVA类只可以扩展一个类，但是可以实现多个接口（C++能extend多个类，即为 c++的多态继承）：

public class bus extend car interface bounceable ,serieable{

}

d.接口可以扩展别的接口，但是不能设计任何内容（不能修改父类中的任何内容）：

public class bounceable extern moveable{

}

第三章运算符和赋值

1.赋值：

1.1 原始赋值：两个byte数据相加类型为int ;byte a =byte_b +byte_c; (错误)

1.2 引用变量赋值：Button b =new Button();

2.原始转换：隐含转换、显式转换（=C++的强制转换）:short a =(short)b;

当扩展转换发生时会出现隐含转换；当需要缩小转换时需要显示转换。

3.传递对象引用变量：void dostaff( Foo g) { g =new Fool() ; }相当于对被传递的 g对象进行重定义。

4.变量就像一个具有指定类型的位容器。

第四章流程控制和异常处理、断言

1.标号的for while循环 break continue语句： break outer;

2.异常层次结构：

3.断言机制：assert(i<1);

a.assert作为关键字，不可用作标示符。

b.断言可以被打开，也可以关闭，默认为被禁用的（关闭）

启用：java -ea/-enableassertions com.geeksamnoymous.Testclass

禁用：java -da/-disableassertions com.geeksamnoymous.Testclass

第五章面向对象、重载和重写、构造函数及返回类型

1.HAS-A IS-A 的关系。

2.重写与重载的关系。

重写方法不能有比被重写方法限制更严格的访问修饰符，public >protect>private.

重写方法要比被重写方法抛出更少或者更有限的异常。

重写方法和被重写方法需要相同的形参，相同的返回值类型。

重载需要不同的形参列表，可以改变返回值类型，访问修饰符，不同的异常。

重载只不过是名称重用，

3.构造函数：

4.合法返回的类型，原则：

第六章 java.lang—Math类、字符串和封装器

java.lang类，基础类，自动导入，不需import。

1.String类（静态的，不变的）

a.语法：

String s =new String{“abcdef”};String对象–字符串定义及初始化；

String s = “abcdef”;

String对象是不变的，但是其引用对象不是的，可以引用不同的值：

s =s.concat{“more ref”}; 与 s.concat{“more ref”}; 两个语句完全不同；

b.成员方法：public char charAt(int index);…

2.StringBuffer类（可擦写的，变化的，重复赋值的）
a.重要方法：

public synochonized StringBuffer append(String s);…

3.Math类:

abs;ceil;floor;max;random;round;sin;cos;tan;sqrt;toDegree;toRadians;

4.封装器类：

Boolean;

Byte;

Charater;

Double;

Float;

Integer;

Long;

Short;

Interger i1 =new Integer{42};

Interger i1 =new Integer{“42”};

5.封装器类的转换功能：

xxxValue;

parseXxx;

valueOf;

toString;

toXxxString;String s3 =Integer.toHexString{254};

6.equal()比较方法概述:(只比较对象，返回布尔值，ture.false,)

比较变量；引用变量比较equal()；原始变量比较==;

比较对象：equal()：x1.equal(x2);

第七章对象和集合

1.Object 的类部分方法：

equals(Object obj)

finalize() 不能被使用的对象，垃圾搜集器。。。

hashCode() 表示对象的散列代码int的值??

notify() 唤醒正在等待该对象锁定的一个线程

notifyAll()

wait()

toString() 返回对象的文本表示。

2.重写equals():

对象比较，必须要重写此方法，因为不同类型的对象，比较的KEY VALUE都是有差异的：eg:

if((o instanceof Moof) && (((Moof) o).getMoofvalue()= this.moofValue))

{ return true;}

else

{ return false;}

a.equals() toString() haseCode() 都是公有的，注意是要重写，不是重载；

b.equals()约定：

自反性，对称性；可传递性；一致性；x.equals(null)应该返回false。

3.重写haseCode()-----设计思想参考数据结构的哈希表机制。(难点)

a.散列码----对象的ID号。HashMap HashSet；

如果两个对象相等，它们的散列码也必须相等。

提高搜索速度是散列码设计的预定目标。

b.设计hashCode()

class HasHash{

public int x;

HasHash{int xVal}{

x =xVal;}

public boolean equals{ Object o}{

HasHash h =(HasHash) o;

if(h.x ==this.x){

return true; }

else{

return false; }

}

public int hasCode{} {

return (x *17); }

}

4.集合 (Java.util中的 Collections Framework)

a.集合的操作：

对象添加到集合；集合中删除对象；查找一个对象是否位于集合中；

从集合中检索对象；遍历集合，一个一个的查找每个元素（对象）。

b.集合架构的主要接口和类：

核心接口：Collection ;Set ;Sorted Set ;LIst; Map ;Sorted Map.

核心具体设计类：

HashMap ; HashSet ; ArrayList ; Hashtable ; LinkedHashSet ; Vector;

TreeMap ; TreeSet ; LinkedLIst; LinkedHashMap .

具体架构关系示意图：

c.集合的三种基本形式：Lists ;Maps :Sets.

d.分类和排序

e.集合具体设计类的特征对比描述:

5.垃圾搜集

a.基础概念：

Java的垃圾搜集器为内存管理提供的一种自动解决方案，缺点是不能完全控制它什么时候执行以及什么时候不执行。

使用内存时，通常处理栈、堆，Java中的常量池和方法区域。

堆是Java对象所在的内存部分，堆是垃圾搜集器处理的所涉及的一个也是唯一一块内存。

当没有任何活线程能够访问一个对象时，该对象就符合垃圾搜集条件。

b.编写代码使对象符合垃圾搜集条件

空引用：StringBuffer sb;…; sb =null; //sb符合垃圾搜集条件

重新为引用变量赋值：StringBuffer a =“hello”;StringBuffer b =“world”; a =b ; //"hello"符合垃圾搜集条件

隔离引用：隔离岛、对象岛：一组对象，相互引用，但是任何活线程都无法访问他们，即它们与外界隔离。

c.强制执行垃圾搜集请求
Runtime对象为直接和虚拟机通信提供了一种机制。Runtime.getRuntime();返回Runtime对象Singleton.

垃圾搜集的最简单的方法：System.gc();

d.垃圾搜集前进行清理–finalize()方法

Java提供的一种机制，可以使对象在被垃圾搜集删除之前运行某些代码。这些代码位于finalize()方法中；

由于垃圾搜集没有做出任何保证，放入类重写方法中的finalize() 任何代码无法保证运行，建议不要放入任何实质代码；

finalize()方法的两点特性：

对于任何指定对象，finalize()方法只会被执行一次；

调用finalize()方法，编写某个对象的引用传递给另外一个对象，可以有效避免其被垃圾搜集器删除。

6.Java 2中的高级垃圾搜集

a.引用类派生于抽象类Reference，是更复杂的内存管理，是WeakReference（弱引用）的子类，WeakReference和

PhantomReference 类位于Java.lang.ref包中；

b.引用排序：

强引用（默认引用为强引用）：软引用：弱引用：幻影引用：

c.对象排序：

强可到达：软可到达：弱可到达：幻影可到达：不可到达：

第八章内部类

1.编写”常规“内部类代码：

a.实例化内部类方法：

从外部类代码内实例化内部类；

从外部类实例代码之外创建内部类对象；(如果想创建内部类实例，必须先创建外部类实例)

MyOuter mo =new MyOuter();

MyOuter.MyInner inner =mo.new MyInner();

或者：

MyOuter.MyInner inner =new MyInner().new MyInner();

b.从内部类中引用内部或者外部实例：

引用内部类自身： this

从内部类代码内引用(外部 this、外部类实例），使用.this

2.方法本地内部类

方法本地内部类只能在定义该内部类的方法内实例化。

内部类不能使用该内部类所在方法的局部变量，除非该变量定义为final。

3.匿名内部类

a.第一种形式的普通旧匿名内部类：(创建指定类型类的子类)

class Popcorn {

public void pop(){ System.out.printIn(“popcortn”) ;}

}

Class Food{

Popcorn p =new Popcorn() {

public void pop()｛

System.out.printIn(“annoyymous popcortn”) ;}

public void sizeze()｛

System.out.printIn(“annoyymous sizeze”) ;}

} ;//如果再内部类引用上调用父类定义中没有的方法，编译器都会报错。

} ;//匿名内部类:定义新类为 Popcorn的子类，重写pop()方法。赋值给对象p.

public void pop()｛

p.pop(); //success

p.sizeze();//fail //如果再内部类引用上调用父类定义中没有的方法，编译器都会报错。

}

}

b.第二种形式的普通旧匿名内部类：(创建指定接口类型的匿名设计类)

c.参数定义的匿名内部类

class MyWonderfulClass{

void go() {

Bar b =new Bar();

b.doStuff(new Foo() {

public void foof () {

System.out.printIn(“foofy”); }

});

}

}

interface Foo {

void foof();

}

class Bar {

void doStuff(Foo f){ }

}

4.静态嵌套类(顶级嵌套类/静态内部类)：

静态类的内部成员，不是一个内部类；

因为是静态的，所以不需要封装类的任何实例；不和封装类的任何实例共享一种特殊的关系。

class BigOuter {

static class Nested {}

}

class Broom {

public static void main(String [] args) {

BigOuter.Nested n =new BigOuter.Nested();

}

第九章线程

1.定义、实例化和启动线程：Java.lang.Thread.

a.基础概念：

一个Thread实例----其实是一个对象。

调用栈和线程一一对应着。

Java.lang.Thread的重要方法：

start()

yield()

sleep()

run()

b.定义线程\实例化线程\启动线程：

扩展Thread类：

class MyThread extends Thread {

public void run (){

System.out.printIn(“abc 0”);

}

public void run (String s){

System.out.printIn("String in run is "+s);}

}

MyThread t =new MyThread();//实例化线程

t.start();//启动线程

重写run()方法、设计java.lang.Runnable：

class MyRunnable implements Runnable {

public void run() {

System.out.printIn(“abc”);}

}

MyRunnable r =new MyRunnable();/./实例化线程

Thread tt = new Thread® ;

tt.start();//启动线程

Thread 构造函数：

Thread()

Thread(Runnable target)

Thread(Runnable target,String name)

Thread(String name)

Thread(ThreadGroup group,Runnable target)

Thread(ThreadGroup group,Runnable target ,String name)

Thread(ThreadGroup group,String name)

c.启动线程：

启动和运行多个线程：一旦线程死去，将永远无法重新启动。

线程调度程序：可运行线程被选择运行的顺序是没有保障的。

线程状态：

2.阻止线程执行:

sleep(); 因为静态的，一个线程不能让另外的线程睡眠。当sleep() 调用时，是让当前正在运行的线程睡眠。

yield(); 静态的，使当前运行的线程回到可运行状态，以让具有相同优先级的线程获得运行机会

join(); 非静态的，让一个线程加入另一个线程的尾部。

a.睡眠:

Thread.sleep(5601000);//静态方法//sleep for 5s

b.线程的优先级和让步:

设置线程的优先级：

t.setPriority(8);

Thread.MIN_PRIORITY (1)

Thread.NORM_PRIORITY (5)

Thread.MAX_PRIORITY (10)

c.其他三种情况可能使线程离开运行状态：

run();

在对象上调用wait();

线程不能在对象上获得锁定，它正试图运行该对象的方法代码。

3.同步代码

使用同步等待、通知和通知所有的编写代码，以保护并发访问和线程之间的通信。

private synchronizedvoid makeWithdrawal(){//使用同步，可以避免查询和取款被打断，保持为原子操作。

if(acc.getBalance()>= amt){

System.Out.printIn(Thread.currentThread.getName()+“is goning to withdraw”);

try {

Thread.sleep(500); }

acct.withdraw(amt);

System.Out.printIn(Thread.currentThread.getName()+“complete withdraw”);}

else {

System.Out.printIn(Thread.currentThread.getName()+"not enough cash "); }

}

}

a.同步和锁定

同步通过锁定来工作；

JAVA的每个对象都有唯一一个内置锁；当一个线程获得该锁，其他线程就无法进入被同步的代码，直到锁被释放。

可以同步方法，也可以同步代码块，不能同步变量。

阻塞：如果线程试图进入同步方法，但是其锁已经被锁定，则说该线程在对象锁上被阻塞。

b.线程死锁

如果两个线程被阻塞，每个线程都在等待对方的锁时，就发生死锁。

如果发生死锁，程序就死掉。

4.线程交互

定义当执行同步等待、通知和通知所有时线程和对象锁之间的交互。???//待细读。。。

wait();

notify(); //单线程等待时使用

notifyAll();//当多个线程等待时使用

第十一章编码标准

1.间隔标准：缩进、行长度、换行和间距。

2.正确处理大括号

3.注释说明：隐藏注释。

4.声明：顺序、位置和初始化、大写。避免影子变量。

第十二章清晰性和可维护性

1.常规程序设计风格注意事项。

变量范围尽可能小；

避免设计没有方法的类；

使用设计模型；

尽可能降低内容可见性；

使用重载而不是逻辑；

避免长参数列表；

不要从构造函数调用可能重写的方法；

编写接口代码；

当需要继承的时候使用抽象类；

使完成的对象符合垃圾搜集条件；

不要超过需要创建太多的对象；

避免深度嵌套和复杂逻辑；

使用符合JavaBean命名规范的读取器和设置器；

不要做面向对象领域的面向过程的程序员：避免使用大而全的大功能类（面向过程的思想）

尽可能时变量和类成为自解释型；

使用核心API；

如果找不到需要的异常类，就开发自己的异常类；

不要返回错误代码；

使异常具备字符串构造函数参数；

2.遵守基本的面向对象的设计原则：

隐藏实现细节；

使用合适的类粒度；

限制再分子类；

使用合适的方法粒度；

使用封装；

隔离可能改变的代码；

3。不要重新开发轮子

使用核心API；

使用标准设计模型；

4、正确的处理错误

不要返回错误代码；

不要发送太多的命令行消息；

在适当的地方使用对话框；

正确的抛出检查异常；

合适的创建和抛出自己的异常；

捕获低级实现异常，而要抛出高级业务异常；

是自己定制的异常类具有一个String构造函数(以获得详细信息)；

永远不要吃掉异常；

声明所以异常，而不只是它们的子类型。

第十三章设计图形用户界面

1.创建可用、可扩展的GUI：

对终端用户，设计为可用的，友好的；

对开发，设计为可靠的，可维护性的；

a.Swing组件，Jtable组件;

b.模型-视图-控制器（MVC: Model-View-Controller）

c.错误处理、监听器和内部类

3.使用案例和业务功能

4.良好的屏幕设计原则：

平衡和混乱

逻辑组和工作流

导航和命令

5.选择什么组件：(Swing组件/Jtable组件)

6.项目的屏幕布局

7.菜单和导航

8.消息、反馈和对话框

9.GUI中怎样使用颜色

10.怎么样测试GUI：

设计测试：项目设计阶段，和客户共同定义，反复修改

代码测试：编码阶段完成后，测试

原文：https://blog.csdn.net/cbk861110/article/details/7768696