static关键字

package csdn;public class staticWord {public static void main(String[] args) {funStatic fs1 = new funStatic();funStatic.showA();fs1.b = 2;fs1.showB(); // 2System.out.println("----------");funStatic fs2 = new funStatic();funStatic.a  = 3;funStatic.showA();fs2.showB(); // 1}
}class funStatic {public static int a = 1; //静态的公共的。int b = 1;static void showA() {System.out.println("a = " + a);}void showB() {System.out.println("b =" + b);}
}/** 结果* *  a = 1b =2----------a = 3b =1* * static 关键字：* 从上面的分析, * 1, 静态里面不能有普通属性, 普通方法, 因为静态属于类, 跟随类先加载出来在方法区。* 2, 静态在方法区的静态区域, 还是那句话, 属于类, 它被修改, 值也发生变化。* 3, 变量却不同, 它跟随对象而变。* conclusion : * 普通方法, 字段属于对象, 对象变, 小心对应的值。* 静态属于类, 一变, 则对应的值也变, 它一直在, 像无脸男一样。* 优先对象加载。* 静态里面只能调用静态。* */

final 关键字

class A {public final void show() {System.out.println("say hello to goodbye!");}public final int a = 0;//a = 0; 错误
}class B extends A {/*public void show() {}  错误*/}/*final conclusion:** 被final修饰的类不可被继承。** 被final 修饰的方法不可以被重写。* * final 修饰的变量不可被改变, 被当作常量。* */

this关键字

class word {String hello;String rye;int index;public word() {}public word(int index, String rye, String hello) {//this();this("hello");//this 调用构造函数。 但是构造函数 只能出现在构造方法里面的第一行，有且只有一个。this.rye = rye;this.index = index;//this 区分全局与局部变量。}/*类比.net里面的this关键字，它只能指代这个类，this.类里面的属性和方法。* 却不能像Java一样 用this调用自身的构造函数。* */public word(String hello) {		this.hello = "hello";		}//word有三个方法的重载，且在同一个类中，参数个数不同，或者参数的类型不同。与返回值无关，与参数列表有关。
}

继承里面的关键字 super

package csdn;public class C12_6 {public static void main(String[] args) {son s = new son();s.show();System.out.println("---------");son ss = new son("rye girl");ss.show();}
}class father {	String name; String sex;double money;private String wife;public father() {System.out.println("父类无参构造。");}public father(String name, String sex) {super(); //object（父类） 的构造函数this.name = name;this.sex = sex;System.out.println("父类两个带参数的有参构造。");}public String getWife() {return wife;}public void setWife(String wife) {this.wife = wife;}public void show() {System.out.println("i am a father!");}}class son extends father{private String wife;double money;public son() {super();System.out.println("子类的无参构造。");}public son(String wife) {super("les", "male");this.wife = wife;System.out.println("子类的有参构造。");}public void show() {System.out.println("i am your son!");}public void setWife(String wife) {this.wife = wife;}public String getWife() {return wife;}
}/*
结果:父类无参构造。子类的无参构造。i am your son!---------父类两个带参数的有参构造。子类的有参构造。i am your son!super 作用：* 1, 区分父子类; * 2,调用父类构造函数, 也要把super放在构造第一行。与this 有异曲同工之妙, 只是关键字不同。* super("","","" ...);* 3, 可以理解为父类的地址。* * 注意在调用构造函数时, jvm 先加载父类的构造。但是在使用对象的方法, 或者对象的属性时, 子类* 里面有就用自己的, 没有就拿爸爸的。* * 与.net base 区分。* 语法不同而已, 也是指代父类。* *  public student() : base (3,"","",""){Console.WriteLine("学生构造。");}* */

代码块 （三个）

package csdn;public class codePiece {public static void main(String[] args) {//代码块： 规定代码的生命周期的范围, 出现在方法里面, 或者类中方法外{//普通代码块：运行完便消失, 节约资源的一种方式。 int a = 1;System.out.println(a);}System.out.println("-------------");code c = new code();c.show();}
}class code {String java;String C;String OC;public code() {System.out.println("code无参构造。");}{//构造代码块 在构造函数初始化时 便调用System.out.println("非类方法外, 构造代码块。");}static {//静态代码块System.out.println("非类方法外, 静态代码块。");}void show() {{int a = 0;System.out.println(a);}{int a = 0;System.out.println(a);}}
}/*结果：* 
1
-------------
非类方法外, 静态代码块。
非类方法外, 构造代码块。
code无参构造。
0
0* * * conclusion:* 方法里面的代码块, 和非方法类里面的代码块。* * 非方法里的代码块分为 静态代码块和构造代码块。* * 静态代码块优先构造代码块, 构造代码块优先构造函数出现。* */

单例模式

package csdn;public class single {String name;static single s = new single();//单例设计模式 : 让一个类只能生成一个对象//先将构造方法私有化, 让外部不能创建 对象, 而通过一个方法来访问这个对象一次。//既然不能new 对象, 那么怎么访问这个方法? 所以静态就来了private single() {}		public static single show() {return s;}		
}class testSingle {public static void main(String[] args) {single s1 = single.show();single s2 = single.show();System.out.println(s1 == s2);//true//说明是同一个对象。 私有化构造, 利用静态实现单例, 让这个对象只出现一次。}
}