Java关键字static静态代码块和final基础二

点击(此处)折叠或打开

1. package com.pp;
   
2. 
   
3. public class StaticFinal
   
4. {
   
5.     static int a =9 ;//成员变量：static成员变量，也叫静态成员变量.可以通过类名使用这个成员变量
   
6.     final int FFb = 0;
   
7.     
   
8.     public static void run()
   
9.     {
   
10.         System.out.println("staic is runing");
    
11.     }
    
12.     public final void FFrun()
    
13.     {
    
14.         System.out.println("Final FFrun is runing");
    
15.     }
    
16.     
    
17.     public static void OKrun()
    
18.     {
    
19.         System.out.println("父类OK staic is runing");
    
20.     }
    
21.     
    
22.     public static void main(String[] args)
    
23.     {
    
24.         // TODO Auto-generated method stub
    
25.         /**
    
26.          * static关键字：可以用在属性、方法、类上。
    
27.          * static修饰成员变量：标示这个类不管生成了多少个对象，这多个对象共同使用这一个static所修饰的属性.
    
28.          * 可以通过类名使用这个静态成员变量
    
29.          * 静态成员变量具有单独的内存区域。java推荐使用类名直接访问静态成员变量
    
30.          */
    
31.         
    
32. /*        
    
33.         StaticFinal ss01 = new StaticFinal();
    
34.         StaticFinal ss02 = new StaticFinal();
    
35.         ss01.a = 10;
    
36.         System.out.println(ss02.a);
    
37.         StaticFinal.a = 89;
    
38.         System.out.println(ss02.a);
    
39.         System.out.println(ss01.a);
    
40.         
    
41.         /*
    
42.          * static修饰的方法也叫静态方法，静态方法具有单独的内存区域。java推荐使用类名直接访问静态方法。
    
43.          * 类名.方法(参数....);
    
44.          * static方法可以被继承，但是不能被重写。静态方法具有单独的内存区域。
    
45.          */
    
46. //*/        
    
47. /*        StaticFinal.run();
    
48.         
    
49.         CC cbb = new CC();
    
50.         cbb.OKrun();
    
51.         cbb.FFrun();
    
52.         
    
53.         HKID hkid = new HKID();
    
54.         hkid.FFrun();
    
55. */        
    
56.         Pensol pp = new Boy();
    
57.         Pensol ppOK = new Boy();
    
58.         
    
59.         //pp.adress = new Adress();//编译错误，因为改变了adress指向的对象的地址
    
60.         pp.adress.name = "Shang Hai";//编译通过,因为adress所指向的地址没有变，只是对象里面name的内容改变了。
    
61.         
    
62. 
    
63.     }
    
64. 
    
65. }
    
66. 
    
67. class CC extends StaticFinal
    
68. {
    
69.     int a;
    
70.     static int b = 0;
    
71.     //static方法可以被继承，但是不能被重写。静态方法具有单独的内存区域。
    
72.     public static void OKrun()
    
73.     {
    
74.         //a++; //一个类中，静态方法不能访问非静态的成员变量！！原因是静态方法可以使用类名调用，但是非静态成员变量不能通过类名访问。
    
75.         b++;
    
76.         System.out.println("子类CCOK staic is runing");//静态方法具有单独的内存区域，不在对象的内存中。
    
77.     }
    
78. }
    
79. 
    
80. //当一个类被final修饰的时候，表示这个类是一个终态类，不能被继承。
    
81. final class HKID extends StaticFinal
    
82. {
    
83.     //final修饰属性：当一个属性被final修饰的时候，表示这个属性是一个终态属性，不能被重新赋值。
    
84.     final int b = 0; //标示 b是一个常量。 final属性必须赋初始值
    
85.     
    
86.     //final修饰方法：当一个方法被final修饰的时候，表示这个方法是一个终态方法，不能被重写。
    
87.     public static void OKrun()
    
88.     {
    
89.         System.out.println("子类HKID staic is runing");//静态方法具有单独的内存区域，不在对象的内存中。
    
90.     }
    
91. }
    
92. 
    
93. class Boy extends Pensol
    
94. {
    
95.     static
    
96.     {
    
97.         System.out.println("静态代码块-->标示这个Boy已经加载到java虚拟机了");
    
98.     }
    
99.     
    
100.     public Boy()
     
101.     {
     
102.         System.out.println("Boy构造方法");
     
103.     }
     
104. }
     
105. 
     
106. class Pensol
     
107. {
     
108.     //adress所指向的对象的地址不能改变。
     
109.     final Adress adress = new Adress();
     
110.     
     
111.     /*
     
112.      * 静态代码块：和方法一个级别，只能放在类里面。
     
113.      * 静态代码块先于构造方法执行。
     
114.      * 当class文件加载到java虚拟机上时，静态代码块已经执行了。
     
115.      * 而构造方法时等class文件加载完毕后，实例化这个类的时候执行的。
     
116.      * 不管生成多少个对象，static代码块只是执行一次，因为class文件加载到java虚拟机上，只需要加载一次就可以了。
     
117.      */
     
118.     static
     
119.     {
     
120.         System.out.println("静态代码块-->标示这个Pensol已经加载到java虚拟机了");
     
121.     }
     
122.     public Pensol()
     
123.     {
     
124.         System.out.println("Pensol构造方法");
     
125.     }
     
126. }
     
127. 
     
128. class Adress
     
129. {
     
130.     /*
     
131.      * 对于final类型的成员变量,有两种赋初值方式：
     
132.      * 1.在声明final成员变量的时候就赋值。
     
133.      * 2.在声明final成员变量的时候不赋值，但是类的所有构造方法给final成员变量赋值。
     
134.      */
     
135.     final int bbk = 10;
     
136.     final int ads;
     
137.     String name = "Bei jing";
     
138.     
     
139.     public Adress()
     
140.     {
     
141.         ads = 10;
     
142.     }
     
143.     
     
144.     public Adress(int ads)
     
145.     {
     
146.         this.ads = ads;
     
147.     }
     
148. }