java基础学习笔记

一、 Static关键字（出现在三个地方：属性前、内部类前和方法前）(注：Test是类名，Demo是静态内部类，Demo1是普通内部类)

A. Static属性只和类相关，与对象无关，使用方法：类名.静态属性。有对象肯定就会有类（先有类才会有对象），这样就可以调用static属性

B. 内部静态类：在main方法中创建内部类对象时，应写成：Test.Demo demo=new Test.Demo();

C. 由于main方法是静态方法，在执行main方法时还没有创建内部类对象，当在创建内部类时，应先将外部类new出之后，在new内部类，即Test.Demo1 demo1=new Test().new Demo1()。（补充 ：system.out.println();方法，system本身是一个类，out是其中的一个方法，但其本身也是一个对象，就可以调用它内部的println方法）

二、构造方法私有化（构造方法（即构造器）前加Private）

A. 单例模式：又叫单态，由于构造器私有，所以别人不能new，可创建一个本类的属性，通过一个静态方法换回一个自身的对象，不管对象被创建多少个，它始终只有一个对象，例：

public class TestSingle{

//单例 或 叫单态

//构造器私有

//创建一个本类的静态属性

//通过一静态方法换回一个自身的对象

private static TestSingle single=null;

private TestSingle(){}

public static TestSingle getTestSingle(){

if(single != null){

return single;

}else{

return new TestSingle ();

}

}

}

public class Main{

public static void main(String[] args){

TestSingle s1=TestSingle .getTestSingle();

TestSingle s2=TestSingle .getTestSingle();

System.out.println(s1==s2);

}

}

三、对象数组（数组的每个元素都是一个对象）

如：public class ObjectArrary {

String name;

int age;

public ObjectArrary(String name){

this.name=name;

}

public ObjectArrary(String name,int age){

this.name=name;

this.age=age;

}

public String getObject(){

return "姓名： "+this.name+" 年龄："+this.age;

}

}

public class GetObject {

public static void main(String[] args) {

ObjectArrary[] a=new ObjectArrary[3]; //这里只是定义数组和数组的长度

a[0]=new ObjectArrary("a",21); //给数组元素赋值

a[1]=new ObjectArrary("b",21);

a[2]=new ObjectArrary("c",21);

//也可以写成：ObjectArrary[]a={newObjectArrary("zhang",22),newObjectArrary("wei",21),

newObjectArrary("xiao",22)};

for(int i=0;i<a.length;i++){

System.out.println(a[i].name+" "+a[i].age);

}

}

}

四、JDK新支持

A. 可变参数，如下：

public class Main{

public static void main(String[] args){

getInt(1,2,3,4);

getInt(1);

getInt(new int[]){1,2,3,4};

}

public static void getInt(int ...is){ //…表示参数没有限制，只是整型数组，数量可变

for(int i:is){

System.out.println(i);

}

}

}

B、自动拆箱、装箱

就是简单数据类型和对象可以互相转换，如：

Int i=new Integer(3);

Integer t=5;

C、泛型

ArrayList<String> list=new ArrayList<String>();

List.add(“str”);

D、注解：是给程序看的，给编译器看的，有的注解可以控制程序的流程

E、静态导入：将静态方法用import导入，在调用的时候，就可以直接写方法名

Import static com.itszt.swallow.Person.show;

在调用时，直接写：show();

(com.itszt.swallow为包名，Person是类名，是静态方法名)

F、代码块：

Ø 普通代码块

Ø 构造块（游离块和构造块功能重复，一般不用游离块）

Ø 静态代码块

Ø 同步代码块，其中此代码块在多线程中部分进行讲解

比较各代码块的执行顺序：（静态代码块à游离代码块à构造方法块）

public class Daimakuai {

//游离块，又叫构造块

{

System.out.println("这是父类游离块");

}

public Daimakuai(){

System.out.println("这是父类构造方法块");

}

static{

System.out.println("这是父类静态代码块");

}

public void go(){

System.out.println("这是父类普通方法");//被对象调用的时候执行

}

}

public class Daima extends Daimakuai{

//游离块，又叫构造块

{

System.out.println("这是子类游离块");

}

public Daima(){

System.out.println("这是子类构造方法块");

}

static{

System.out.println("这是子类静态代码块");

}

public static void main(String[] args) {

// TODO Auto-generated method stub

Daimakuai d=new Daima();

}

}

此段代码运行的结果是：

这是父类静态代码块

这是子类静态代码块

这是父类游离块

这是父类构造方法块

这是子类游离块

这是子类构造方法块

（补充：system.exit()是终止程序，退出系统）

五、内部类

Ø 局部内部类：在方法中写的类

public class Main{

public static void main(String[] args){

}

public void show(){

class Person{

String name;

public void gerMsg(){

name="wei";

}

}

new Person().getMsg();

}

}

Ø Final关键字

public class Main{

public static void main(String[] args){

}

//1、局部内部类中，如果调用方法的局部变量，则该变量必须声明为final类型

//2、或者把该变量定义为成员变量，即全局变量

//String name=”aa”;

public void show(){

final String name=”aa”;

class Person{

public void gerMsg(){

System.out.println(name);

}

}

new Person().getMsg();

}

}

² Final修饰一个变量时，这个变量值就是不能被改变，即定义一个常量

² 在方法前，代表此方法不能被重写或覆盖

² 在类前，代表此类不能被继承

² 在使用常量时，最好将final和static一起使用，调用时直接使用类名点常量名，即类名.常量名。如final static String s= “person”,调用时String a =Test.s;（Test为类名）。

六、 抽象类

Ø 抽象类即，类中有个抽象方法（只有声明，没有实现），关键字abstract，抽象类不能new。

Ø 当一个类继承抽象类时，要实现抽象类中的抽象方法，如果这个类也是抽象类，就不用实现父类中的抽象方法了，直接继承。

Ø 不能用final来声明抽象类，因为final声明的类不能被继承，而抽象类必须被继承，那么抽象类中的抽象方法就无法被实现，那这个抽象类就没有任何意义了

Ø 抽象类不能被new，但是有构造方法，在子类new创建对象时，父类的构造方法就会被执行

七、接口

Ø 接口中的属性就是常量，默认的是final声明的，即常量必须赋值且不能改变，所以属性都是常量(public final static)int i=10，所以方法都是抽象方法(public abstract)void go();

Ø 理解上，可以认为如果抽象类中的所有方法都是抽象方法，则这个抽象可以定义为接口

Ø 实际上，接口不是类，接口就是接口，是一种规范

Ø Java中类是单根继承的，即只能继承一个类，但一个类可以实现多个接口；接口可以继承接口，且接口可以继承多个接口

未完待续。。。。。。。。。。。。。

想了解很多请点击http://itszt.losoon.com/a/xueyuanxinde/2012/0320/235.html