java技术总结

java技术总结

1.所有使用类定义的变量都是引用变量。Java使用类的构造器来创建该类得对象。

2.java语言的特征：封装（public,private,protected）、继承（extends）、多态（使用继承实现类复用时将子类的对象赋给父类的引用时实现了多态（引用变量在编译时类型为声明类型，运行时类型为赋给变量的对象类型），组合则不行【什么是组合？】组合为在java类里嵌入需要组合的对象）。如何判断使用继承还是组合：继承（b是不是a），组合（a是不是b的一部分）。

3.类的修饰符（public、final（不能被继承）、abstract（抽象类））

4.属性的修饰符（public、protected、private、static（此属性属于改类）、final）

5.方法修饰符（public、protected、private、static、final（不能被重写）、abstract）

6.类的成员：构造器（使用new关键字来调用构造器）、属性、方法

7.static修饰的成员表明属于这个类而不属于这个对象，static修饰的成员只能访问static修饰的成员，不能访问非static修饰的成员。而非static修饰的成员能访问static修饰的成员。

static修饰的成员中不能直接调用static成员，因为直接调用时成员前面默认添加this，而静态成员属于类，没有对象。

8.构造器方法名必须和类名一致，定义构造器方法时不能设置返回值类型，构造器默认返回值为创建的对象。

9.static修饰的成员既可以通过类来调用也可以通过对象来调用，非static修饰的成员只能通过对象来调用。

10.引用变量里存放的仅仅是一个引用（一个地址值，存放在栈内存），这个引用指向实际的对象（存放在堆类存）。Java的参数传递机制为值传递，即传递到参数中的是一个副本，在对参数的操作实际上也就是对副本的操作不影响源数据。当参数为一个对象时，传递的实际是这个引用的地址值，根据这个地址值操作对象时其实也就是在操作实际的对象。参数为一个List时传递的是什么（传递的也是一个地址值）

11.this为一个指针（即一个引用），它指向调用此方法的对象。

12.方法重载：同一个类、同一个方法名，参数列表不同。方法重写：子类重写父类的方法。

2011.4.24java讲义（125-165）

1.成员变量（在类范围里定义的变量，生命周期和类共存亡）：实例属性（不以static修饰），类属性（以static修饰）。局部变量（在方法类或代码块里定义的变量，生命周期在整个方法内）：形参、方法局部变量、代码块局部变量。

2.成员变量初始化是内存的分配：在类初始化完成后系统隐式的为类创建一个类对象，紧接着创建一个对象，并把这个对象赋给引用变量。在创建对象时不为类属性分配内存。

3.局部变量的初始化：局部变量经过显式初始化后才能使用，在局部变量初始化时系统才会为局部变量分配内存空间。

4.封装：将该类的属性隐藏在类的内部，通过该类提供的方法访问类的属性。

5.访问控制符：

	private	default	protected	public
同一个类中	是	是	是	是
同一个包中		是	是	是
子类中			是	是
全局范围内				是

6.java常用的包

Java.lang:java的核心类，如：String，Math，System，Thread。使用这些类时无需使用import语句导入。

Java.util:包含了java大量工具类/接口和集合框架类/接口，例如Arrays和List，Set.

Java.net:包含了与网络编程有关的类。

Java.io：包含了java输入/输出有关类和接口。

Java.text:包含了java格式化相关的类。

Java.sql:包含了jdbc数据库编程的相关类/接口。

Java.awt: 包含了抽象窗口工具集相关的类/接口，主要用于GUI程序。

Java.swing:包含swing图形编程的相关类/接口。

7.java构造器：java构造器用于在创建对象时进行初始化。在执行构造器之前java已经创建了该对象，只是此对象还不能被外部程序访问。只能在构造器中通过this来引用他。当构造器执行完毕后，此对象作为构造器的返回值，并被赋给对象引用。构造器重载时在一个构造器中调用另一个构造器时使用this（参数1，参数2）方式来调用。

8.类的继承：java继承为单继承，即一个子类只能继承一个父类。通过extends关键字实现。继承后子类可以重写父类方法，重写父类方法后父类方法被覆盖，子类想调用父类方法时通过super关键字调用，super关键字代表父类的一个隐式对象。Overload（重载），overrride（重写），重载主要发生在同一个内的不同方法之间，重写在发生在父类和子类之间。Super不能出现在static方法中。子类调用父类构造器使用super（参数1，参数2）。

9.java引用变量有2个类型：编译时类型，运行时类型。编译时类型由声明该变量时使用的类型决定，运行时得类型由实际赋给该变量的对象决定。如果编译时类型与运行时类型不一致就出现了多态。

10.引用变量的强制类型转换：引用变量只能调用它编译时类型的方法，而不能调用它运行时类型的方法。如果要调用它运行时类型的方法则需要进行强制转换（向上转型）。基本类型转换只能在数值类型之间转换（整数型，字符型，浮点型）。引用类型转换只能把一个父类转换为子类。在进行类型转换之前可以使用instanceof运算符判断是是否可以成功转换。

if（object  instanceof  class）时则可以转换。

11.继承与组合：继承和组合都是为了实现类复用。但是继承破坏了类的封装性。不希望子类访问父类属性时使用private，不希望子类重写父类方法时使用final。希望父类的方法被子类重写而不希望被其他类访问时用protected。组合为将一个类得实例嵌入另一个类中，以实现对其类成员的复用。

12.初始化块：初始化块在构造方法执行之前执行。在执行静态初始化块时会先执行其父类的静态初始化块，一层一层的追溯，最后才执行本类得静态初始化块。

2011.4.27java讲义（167-188）

1.基本数据类型的包装类：

byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

2.包装类通过传入一个字符串来创建包装类对象，入：Float  f1=new  Float(“4.15”)

包装类提供了xxxValue()实例方法，用于获取包装类中基本数据类型值。

如：int i=itObj.intValue()

JDK1.5以后java提供了自动装箱和自动拆箱功能：自动装箱为将一个基本类型变量直接赋给包装类引用变量。自动拆箱为将一个包装类引用变量直接赋给一个基本类型变量。

如:     int a=new Integer("1");

       Integerb=2;

包装类还可以实现基本类型变量和字符串之间的转换，除了character之外的所有包装类都提供了parseXxx(Strings)静态方法，此方法用于将基本类型转化为字符串，如：

       String a="111";

       int b=Integer.parseInt(a);

String还提供了valueOf()此方法用于将其他基本类型转化为String，如：

       String a="111";

       int b=Integer.parseInt(a);

       Stringc=String.valueOf(b);

3.java的toString()方法为自我描述方法返回为：该对象实现类的类名+@+对象的hashCode信息。一般情况下需要重写toString()方法。

4.==和equals比较：

1）==：当两个变量都为基本类型且都为数值型（整型，浮点型，字符型）时，只要两个变量值相等则返回值为true。当两个变量为引用类型时，如果两个引用变量指向同一个变量时返回值为true，否则为false。==不能比较类型上没有父子关系的两个对象。

2）equal：判断两个字符串是否相等根据“字符串的序列”是否相同判断。当两个引用变量指向同一个对象时比较时与==相同。如果想根据别的条件判断两个对象是否相等时需要重写equals方法。数值型不能用equals比较，equals只能比较引用型变量。

==一般用来比较数值型变量，equals用来比较引用类型变量，当使用==比较引用类型变量时与使用equals效果相同。

5.类成员：凡是以static修饰的成员就是类成员。不允许类成员直接访问实例成员原因为：类成员是属于整个类的，类成员的作用域比实例成员的要大，完全有可能出现类成员已经初始化完成而实例成员还没初始化完成，这样会引起很多错误。（但是可以在类成员里通过实例来访问实例成员）

6.单例类：此类始终只能创建一个实例。

public class Singleton {

    //使用一个属性保存已经创建的对象，由于此对象需要被方法访问所以为静态的。

    private static Singleton singleton;

    //为了避免其他类来创建对象所以使用private修饰构造器

    private Singleton(){};

    //由于构造器不能访问所以必须提供一个public的方法去获取单一实例，由于在调用此方法时实例还未创建

    //所以需要用static修饰此方法

    public static SingletongetSingleton(){

       if(singleton==null){

           singleton=new Singleton();

       }

       returnsingleton;

    }

}

7.final修饰符（终结者），修饰类、变量、方法。修饰类时此类不能被继承，修饰变量时一旦此变量被初始化就不能被修改，修饰方法时此方法不能被重写。其中java.lang.Math就是fina类。Object的getClass（）方法为final方法。

8.不可变类：该类的对象创建后该对象的属性值是不可改变的。实现不可变类得规则：

1）使用private、fianl来修饰属性

2）使用带参数的构造器去初始化对象。

3）只为属性生成getter（）方法，不生成setter（）方法。

4）重写hashCode（）和equals（）方法。

9.缓存实例的不可变类。

public class CacheImmutale {

    private final String name;

    private static CacheImmutale[] cache=new CacheImmutale[10];

    private final int objPos;

    private static int pos=0;

    public String getName() {

       returnname;

    }

    public CacheImmutale(String name,int objPos){

       this.name=name;

       this.objPos=objPos;

    }

    public static CacheImmutale valueOf(String name){

       for(int i=0;i<10;i++){

           if(cache[i]!=null &&cache[i].getName().equals(name)){

              returncache[i];

           }

       }

       if(pos==10){

           cache[0]=new CacheImmutale(name,1);

           returncache[0];

       }else{

           cache[pos++]=new CacheImmutale(name,pos);

           returncache[pos-1];

       }

    }

    public static void main(String[] args) {

       CacheImmutale c1=CacheImmutale.valueOf("lipeng");

       CacheImmutale c2=CacheImmutale.valueOf("lipeng");

       System.out.println(c1==c2);

       System.out.println(c1.objPos);

       System.out.println(c2.objPos);

       System.out.println(CacheImmutale.pos);

    }

}

2011.5.12java讲义（188-239）

1.有抽象方法的类必须被定义成抽象类，抽象类里可以没有抽象方法。

2.抽象类和抽象方法都必须使用abstract修饰。抽象类不能被实例化，不能用new；来调用构造方法，此构造器用来被子类调用。abstract修饰的方法只能被子类重写。Abstract和final不能同时存在，在修饰一个方法时abstract和static不能同时存在。同时abstract不能用private修饰。

3.模板模式：如果编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式。

public abstract class SpeedMeter {

    private double turnRate;

    public void setTurnRate(double turnRate) {

       this.turnRate = turnRate;

    }

    public abstract double getRadius();

    public double getSpeed(){

       return java.lang.Math.PI*2*getRadius();

    }

}

public class CarSpeedMeter extends SpeedMeter{

    public static void main(String[] args) {

       CarSpeedMeter carSpeedMeter=new CarSpeedMeter();

       carSpeedMeter.setTurnRate(15);

       System.out.println(carSpeedMeter.getSpeed());

    }

    public double getRadius() {

       return 0.28;

    }

}

4.接口就是一个所有方法都是抽象方法的抽象类，接口只能继承接口不能继承其他类，一个接口可以继承对个接口。接口里的属性只能是常量，接口的方法只能是抽象方法。接口里所有成员都是public访问权限。接口的常量属性是接口相关的，因此只能是final，static。接口里不允许使用静态方法。

5.接口和抽象类：

相同点：

1）都不能被实例化，他们都处于继承树的顶端，用于被其他方法继承和实现。

2）接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

不同点：设计模式上的不同。接口体现的是一种规范，而抽象类则体现的是一种模板。

1）  接口里不能包含普通方法，而抽象类则可以包含。

2）  接口里不能包含静态方法，而抽象类里则可以定义静态方法。

3）  接口里只能定定义静态常量属性，而抽象类里可以定义普通属性。

4）  接口不包含构造器，而抽象类里可以包含构造器。

5）  接口里不能包含初始化块，但抽象类里完全可以包含初始化块。

6）  一个类只能继承一个父类。而一个接口可以继承多个接口。

5.简单工厂模式：比如要组装一台带有打印机设备的电脑，首先要有一部电脑这个电脑里有个安装打印设备的插槽，这个插槽遵循同用的打印设备规范。其次要有一个打印设备，这个打印设备也遵循打印设备规范。这些东西都准备就绪后在一个组装工厂中完成电脑与打印设备的组装，工厂提供一个符合规范的打印设备，并将此设备安装在电脑上。

//准备一台电脑

public class Computer {

    //打印设备规范

    private OutPutoutPut;

    public Computer(OutPut outPut){

       this.outPut=outPut;

    }

    public void keyIn(String msg){

       outPut.getMsg(msg);

    }

}

//打印设备规范定义

public interface OutPut {

    void getMsg(String msg);

}

//准备一台符合上诉规范的打印设备

public class Printer implements OutPut{

    public void getMsg(String msg) {

       System.out.println(msg);

    }

}

//定义一个工厂

public class OutputFactory {

    //根据规范获取一台打印设备

    public OutPut getOutPut(){

       return new NewPrinter();

    }

    public static void main(String[] args) {

       //new一个工厂实例

       OutputFactory factory=new OutputFactory();

       //让此工厂给电脑安装打印设备

       Computer computer=new Computer(factory.getOutPut());

       //打印设备安装完毕，使用打印设备

       computer.keyIn("aa");

    }

}

6.命令模式：某个方法需要完成一种行为，但这个行为的具体实现无法确定，必须当等到执行该方法时才能确定。首先确定一个接口，此接口中定义一个方法。再定义一个业务逻辑类，在此类中用接口的方法完成业务逻辑操作。对这个接口进行实现，实现后在另一个类中完成业务逻辑的具体操作（传入真正的数组和真正的方法。）

//定义一个命令

public interface Command {

    void process(int[] args);

}

//进行虚拟业务逻辑操作

public class ProcessArray {

    public void process(int[] target,Command cmd) {

       cmd.process(target);

    }

}

//实现接口

public class PrintCommand implements Command{

    public void process(int[] args) {

       for(int a : args){

           System.out.println(a);

       }

    }

}

//完成真正的业务逻辑

public class TestCommand {

    public static void main(String[] args) {

       ProcessArray pa=new ProcessArray();

       int[] target={1,2};

       pa.process(target, new PrintCommand());

    }

}

7.内部类：定义在其他类内部的类叫做内部类。内部类分为：非静态内部类，静态内部类，局部内部类，匿名内部类。

8.非静态内部类：内部类在编译完后生成2个class文件，第一个为其外部类得文件，第二个为其内部类得文件，形式为OutClass$InnerClass.class。在非静态内部类中可以访问外部类的任何成员，但外部类想访问内部类得成员需要使用内部类得对象。

9.静态内部类：使用static修饰的内部类为静态内部类。在静态内部类里不能访问外部类的实例成员，只能访问外部类得类成员。外部类依然不能访问静态内部类的成员，但可以使用内部类的对象来访问其成员。

10．使用内部类：在外部内以外的地方访问内部类时内部类不能用private修饰，在外部类以外的地方定义非静态内部类时用 OutClass.InnerClass inner=new OutClass().newInnerClass()。在外部类以外的地方定义静态内部类时不用外部类的对象，而使用外部类，格式为：OutClass.InnerClass inner=OutClass.new InnerClass();

11.内部类的作用：内部类可以继承其他类。弥补了java中不能多继承的功能缺陷。

12.局部内部类：定义在一个方法里的类，该类只在该方法里有效，局部内部类不能再该方法以外的地方使用他。局部内部内不能使用static修饰，因为他的上一级程序单元为方法，不是类。生成文件的方法与内部类一致。

13．匿名内部类：只需要使用一次的类，用一个接口创建一个对象，此对象必须实现接口的方法。

public interface TestN {

    public int aciton();

}

public class Test11 {

    static void action(TestN testN){

       System.out.println(testN.aciton());

    }

    public static void main(String[] args) {

       action(new TestN()

       {

           public int aciton() {

              return 1;

           }

       });

    }

}

14.枚举类：枚举类继承的是Enum类，而不是Object。当需要一组固定不变的标识时用枚举类型。

public class TestEnum2 {

    //定义两个枚举对象

    private static TestEnum testEnum=TestEnum.A;

    private static TestEnum testEnum2=TestEnum.B;

    public static void main(String [] args){

    //枚举用在switch语句  

       switch (testEnum) {

       case A:System.out.println(testEnum);

           break;

       default:

           break;

       }

    //枚举对象比较，当A.compareTo(B)为-1时表示A在B的前方，如果为0时表示位置一样，即同一个枚举对象，如果为1则表示A在

    //B的后方  

       System.out.println(testEnum2.compareTo(testEnum));

    //获取枚举对象的索引位置

       System.out.println(testEnum.ordinal());

    }

}

2011.5.16java讲义（242-290）

1.集合类继承树

2.集合类的方法：

3使用Iterator遍历集合元素

List list=new List();

Iterator ite=list.iterator();

While(i.hasNext()){

         Objectobj=(Object)ite.next();

Ite.remove();

         List.remove();在迭代过程中修改集合

}

当迭代的过程中修改集合中的元素时会报异常。

4.set：无序不可重复的集合。程序判断时使用equal（）方法来判断两个对象是否相当。

5.hashSet按hash算法来存取集合中的元素，查找元素时按照hashCode的值去查找对象。有很好的存取和查找性能。HashSet不是线程同步的，如果需要线程同步则自己用代码实现。

当两个对象的equal（）和hashCode（）返回值都为true时，则只保存一个元素，当equal（）返回为true，hashCode（）返回为false时则保存2个元素，当equal（）不同，而hashCode（）相等时保存在一个地方，2个值，导致性能下降很多。

6.List：有序可以重复。LinkedList与ArrayList区别。LinkedList是链表结构，ArrayList是数组结构。Vector是线程安全的。

7.Map：是具有映射关系的一组数据结构。Map有以下的方法

8．HashMap和Hashtable的区别：

1）HashMap是线程不安全的，Hashtable是线程安全的

2）HashMap可以为key或value赋一个null，而Hashtable则不能，如果赋了则在运行时出现空指针。

9.线程安全：线程安全问题都是由全局变量及静态变量引起的。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

举例：比如一个 ArrayList 类，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。

　　在单线程运行的情况下，如果Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；

　　而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。

那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 3。这就是“线程不安全”了。

10.判断两个对象是否相等的标准是equal()返回值为true，hashCode（）返回值相等。

11.Collection工具类：

2011.5.23java讲义（749-）

1.什么是线程：一个操作系统同时运行多个任务时，一个任务就有一个进程，一个进程运行时期中包含多个顺序执行流，每一个执行流就是一个线程。进程是系统进行调度和资源分配的独立单位。一个程序运行后至少有一个进程，一个进程里可以包含多个线程，并至少包含一个线程。主线程结束后不会影响子线程。

2.进程的三个特征：

1）独立性：进程是系统中独立存在的实体，他可以拥有自己的独立资源，每一个进程都拥有自己的地址空间，其他进程没有本进程允许不能直接访问他的地址空间。

2）动态性：程序是一个静态的指令结合，而进程是一个正字系统中活动的指令集合。进程有时间的概念，并拥有生命周期。

3）并发性：多个进程可以在一个处理器上并发执行，进程之间不会受到影响。

3.线程的创建和启动：

线程的创建有两种：

1）  定义Thread的子类，并重写run()方法，run()方法是完成一个线程任务的执行流。通过start（）方法启动。在启动后此线程还没有执行，带处理器调度到此线程时此线程才开始执行。Start后只是就绪。访问当前线程时用this.

2） 定义一个类实现runnable接口。此线程类还可以继承其他类。其中多个线程共享一个target对象。适用于多个线程共享一份资源的情况。访问当前线程为Thread.currentThread()

4.线程的生命周期：新建（new）à就绪（Runnable）à运行（Running）à阻塞（Blocked）à死亡（Dead）。

5.线程死亡的方式：

1）run()方法执行完成后此线程正常结束。

2）线程抛出一个未捕获的异常（Exception）或错误（Error）时。

3）直接调用该线程的stop（）方法结束改线程。                         

6.join（）方法：当在一个线程执行流中其他线程调用其join（）方法时当前线程被阻塞，待调用join（）的线程执行完毕后才能执行原线程。

7.后台线程：在后台运行的为其他线程服务的线程被称无后台线程，当一个后台线程的前台线程都死亡后后台线程自然死亡。

8.sleep()方法：在一个线程的run（）方法中执行sleep()方法时，可以阻塞当前线程。

9.yield（）方法：在一个线程run（）方法中执行yield（）方法时，则让当前线程暂停，而不是将当前线程阻塞。

10.改变线程的优先级：通过.setPriority()设置优先级。

11.线程同步：通过

Synchronized(obj){

//obj为同步监视器

}

加锁à修改完成à释放锁

12.同步锁

13.死锁：两个对象相互等待对方释放同步监视器时就发生了死锁。