CoreJava学习笔记5

java中的修饰符

static 表示静态，它可以修饰属性，方法和代码块。

1，static修饰属性（实例变量）（类变量），这个属性就可以用 类名.属性名 来访问，这个属性成为本类的类变量，为本类对象所共有。这个属性全类公有。（共有的类变量与对象无关，只和类有关）。
例：

public class Test{
	private static int testnum;
/*
如果实力变量前加上了static修饰符那么，这个变量叫做类变量
*/
	……
}

类加载的过程，类本身是保存在文件中（字节码文件保存着类的信息）的，java通过I/O流把类的文件（字节码文件）读入JVM（java虚拟机），这个过程称为类的加载。JVM（java虚拟机）通过类路径（CLASSPATH）来找要加载的字节码文件。

类变量，在加载时自动初始化，初始化规则和实例变量相同。

注意：类中的实例变量在创建对象时被初始化，static修饰的属性，类变量，在类加载时创建并进行初始化，类加载的过程只进行一次。类变量只会被创建并初始化一次。

2，static修饰方法（静态方法），使这个方法成为整个类所公有的方法，用
类名.方法名 访问。
例：

public class Test{
	private static int num;
	public int testage;
	public static int test（）{
			num++;
		Test t=new Test();
		t.age
		/*
			在静态方法中只能防问静态属性,但是可以通过一上的
			组合方式进行访问
		*/
	}
}

注意：
1) static修饰的方法，不直接能访问（可以通过组合方式访问）本类中非静态(static)成员（包括方法和属性），本类非静态（static）方法可以访问本类静态成员（包括方法和属性），可以调用静态方法。静态方法要慎重使用。静态方法中不能出现this关键字。

2) 关于静态方法的覆盖问题：

<1>父类中是静态方法，子类中不能覆盖为非静态方法，符合覆盖规则的前提下，父子类中，父类中静态方法可以被子类中静态方法覆盖，但是没有多态。（在使用对象调用静态方法是其实是调用编译时类型的静态方法）
<2>父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。

Java中main方法必须写成static的，类加载时无法创建对象，静态方法可以不通过对象调用所以main方法是静态的。在类加载时就可以通过main方法入口来运行程序。

注意：组合方式，需要在方法中创建一个所需要的对象，用这个对象来调用任意所需的该对象的内容，不再受只能访问静态的约束。
例：

public class Test{
	private int a;
	public static void main(String[] args){
	}
	public static void test(){
		Test t=new Test();
		 t.a=20;
    }
}

3，static修饰初始代码块，这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一个类。

初始化代码块就是在类中的一个代码块，不是方法的实现。可用来初始化类中的属性。

例：

public class Test{
	private static int num;//这个变量叫做类变量
	static{                //静态初始化代码块
   		num=12；
}
}

动态初始代码块，写在类体中的“{}”，这个代码块是生成对象初始化属性时运行的。这种代码块叫动态初始代码块。
例：

public class Test{
	private static int num;//这个变量叫做类变量
	{//动态初始化代码块
   		num=12；
}
}

类在什么时候会被加载，
构造（创建）对象必会加载该类。
调用类中静态方法或访问静态属性也会加载这个静态方法真正所在的类。
构造父类对象时，没有调用子类类中静态方法或访问静态属性，就不会加载子类。
构造子类对象时必会先加载父类。
类加载的延迟加载原则，只有在必须加载时才会加载。

单态模式，是生成一个本类的对象实例

例：
public class TestSingleton{
public static void main(String[] args){
}
}
class Xiao{
/*
懒汉式实现，这种方法实现的单态模式只有在使用到这个
类的对象时才产生对象，但是在多线程情况下会出现问题
*/

private static Xiao x=null;
	private Xiao(){}
	public static Xiao newInstance(){
		if (x==null) x=new Xiao();
		return x;
	}
}

class Wife{
	  /*
饿汉式的实现方法，这种方法实现的单态模式也不太完美，如果
这个类没有得到使用那么就会有一个垃圾对象生成，但是在多线
程条件下不会有问题
*/
	private static Wife w=new Wife();
	private Wife(){}//私有构造方法
	public static Wife newInstance(){
		return w;
	}
} 

final修饰符，可以修饰变量，方法，类

1, final修饰变量（包括局部变量和实例变量）
被final修饰的变量就成为常量（常量名应当大写），一旦赋值不能改变，（可以在初始化时直接赋值，在构造方法里可以为其赋值，只能在这两种方法里二选一，常量不能不赋初值），常量没有默认初始值，final修饰符常和static修饰符一起使用。
例：

public class Test{
	private static final int NUM=2;
//有final修饰变成了常量
	……
}

2，final修饰方法，final修饰的方法将不能被子类覆盖，保持方法的稳定不能被覆盖。

例：

public class Test{
	public final int test（）{
		......
	}
}

3，final修饰类，final修饰的类将不能被继承。final类中的方法也都是final的。

例：

public final class Test{
	public final int test（）{
		......
	}
}

注意：final，不能修饰构造方法，在父类中有常量属性，子类中使用常量属性时不会进行父类的类加载。静态常量如果值可以确定，就不会加载该类，不能确定则会加载该常量所在的类。

不变模式，对象一旦创建属性就不会改变。用final修饰类（强不变模式），用final修饰属性（弱不变模式）。

不变模式的典型体现：java.lang.String类，不变模式可以实现对象的共享（可以用一个对象实例赋值给多个对象引用。）

池化的思想，把需要共享的数据放在池中（节省空间，共享数据）

String类可以用“  ”中的字面值创建对象。String类中，以字面值创建时，会到Java方法空间的串池空间中去查找，有就返回串池中字符串的地址，并把这个地址付给对象引用。没有会在串池里创建一个字符串对象，并返回其地址付购对象引用，当另一个以字面值创建对象时会重复上述过程。

堆空间中创建String类的对象，不会有上述的过程。

例：

public class TestString{
	public static void main(String[] args){
		String str1=”abc”;
		String str2=”abc”;
		String str3=new String(“abc”);
		System.out.println(str1==str2);
		System.out.println(str1==str3);
	}
}
结果是：
true

false//在堆空间中创建的Srting是不会从串池中引用的

String类中的intern()方法会将在堆空间中创建的String类对象中的字符串和串池中的比对，有相同的串就返回这个串的串池中的地址。

不变模式在对于对象进行修改，添加操作是使相当麻烦的，会产生很多的中间垃圾对象。创建和销毁的资源的开销是相当大的。

String类在字符串连接时的效率很低，因为它所产生的对象的属性是不能修改的，连接字符串时就只能创建新的对象。

对于很多的字符串连接，应当使用StringBuffer类或者是StringBuilder，使用这个类的对象来进行字符串连接时，不会有多余的中间对象生成，优化了效率。
例：
上边的字符串连接如果使用StringBuffer如下的写法

public class TestString{
	public static void main(String[] args){
		String str=“a”+“b”+”c”;
/*
以上创建String对象str时会创建1个中间String对象“ab”
如果使很多字符串相连就是穿件出许多的中间对象
         */
		StringBuffer str=new StringBuffeter();
        //使用StringBuffer就不会有中间对象生成
str.append(“a”);
str.append(“b”);
str.append(“c”);
String strs=str.toString();

	}
}

abstract（抽象）修饰符，可以修饰类和方法

1， abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，可以做为对象引用声明的类型，就是编译时类型，抽象类就相当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
例：

public abstract class Test{
	public int test(){
        ……
}
……….
}

2， abstract修饰方法，会使这个方法变成抽象方法，只有声明（定义）没有实现，实现部分以";"代替。需要子类继承实现（覆盖）。
例：

public abstract class Test{
	public abstract int test();//有抽象方法的类一定是抽象类
}

abstract修饰方法就是要求子类覆盖（实现）这个方法。调用时以多态方式调用子类覆盖（实现）的方法，抽象方法必须在其子类中实现，除非子类本身也是抽象类。

• 注意：
• 1) 有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。abstract修饰符在修饰类时必须放在类名前。
• 2) 父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。

修饰符组合使用问题

final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符，因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时期子类都覆盖不了这个方法，final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖，static是可以覆盖的，但是在调用时会调用编译时类型的方法，因为调用的是父类的方法，而父类的方法又是抽象的方法，又不能够调用，所以上的修饰符不能放在一起。

抽象（abstract）方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承的抽象方法的实现）。
方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。(abstract)

模板方法模式

用abstract把制订标准和实现标准分开，制定的标准就是模板，实现就是按模板标准来实现，继承模板，实现模板中相应功能的方法。模板中不允许修改的方法用final来修饰，这个方法不能是方法，为保证安全，模板类中不公开的部分用protected（保护）修饰。