Java面向对象（七）

Java面向对象（七）


目录

• Java面向对象（七）
  
  
  
  • 
    
    
    
    • 二十、static 关键字
      
    • 二十一、单例模式
      
      
      
      • 21.1 饿汉式单例模式代码
        
      • 21.2 懒汉式单例模式代码
        
      • 21.3 饿汉式和懒汉式
        
      • 21.4 单例模式应用场景
        
      
      
    • 二十二、类的成员之四——代码块（初始化代码块）
      
      
      
      • 22.1 静态代码块
        
      • 22.2 非静态代码块
        
      • 22.3 例子
        
      • 22.4 属性赋值的先后顺序
        
      
      
    • 二十三、final 关键字
      
    
    
  
  

二十、static 关键字

• static：静态的，可以用来修饰：属性、方法、代码块、内部类
  
• 使用static修饰属性：静态变量（或类变量）
  属性，按是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
  
  
  
  • 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
    
  • 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
    
  
  
• static 修饰属性的其他说明：
  

（1）静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
（2）静态变量的加载要早于对象的创建。
（3）由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
类变量实例变量类yesno对象yesyes（4）静态属性举例：System.out；Math.PI
4.使用static修饰方法：静态方法
（1）随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
静态方法非静态方法类yesno对象yesyes（2）静态方法中，只能调用静态的方法或属性。
​          非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性。

• static 注意点：
  

• 在静态的方法内，不能使用this关键字、super关键字
  

• 开发中，如何确定一个属性是否要声明为static的？
  

• 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
  

• 类中的常量也常常声明为static。
  

• 开发中，如何确定一个方法是否要声明为static的？
  

• 操作静态属性的方法，通常设置为static的。
  
• 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections。
  

二十一、单例模式

• 单例设计模式：
  就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
  
• 单例模式的两种方式：饿汉式和懒汉式。
  

21.1 饿汉式单例模式代码

1. public class SingletonTest1 {
2.         public static void main(String[] args) {
3.        
4.                 Bank bank1 = Bank.getInstance();
5.                 Bank bank2 = Bank.getInstance();
6.                
7.                 System.out.println(bank1 == bank2);                //true
8.         }
9. }
11. //饿汉式
12. class Bank{
13.        
14.         //1.私有化类的构造器
15.         private Bank(){               
16.         }
17.        
18.         //2.内部创建类的对象
19.         //4.要求此对象也必须声明为静态的
20.         private static Bank instance = new Bank();
21.        
22.         //3.提供公共的静态的方法，返回类的对象
23.         public static Bank getInstance(){
24.                 return instance;
25.         }
26. }

复制代码

21.2 懒汉式单例模式代码

1. //        线程不安全，非懒汉式单例模式完整代码
2. public class SingletonTest2 {
3.         public static void main(String[] args) {
4.                
5.                 Bank bank1 = Bank.getInstance();
6.                 Bank bank2 = Bank.getInstance();
7.                
8.                 System.out.println(bank1 == bank2);                //true
9.                
10.         }
11. }
14. class Bank{       
15.         //1.私有化类的构造器
16.         private Bank(){
17.                
18.         }
19.        
20.         //2.声明当前类对象，没有初始化
21.         //4.此对象也必须声明为static的
22.         private static Bank instance = null;
23.        
24.         //3.声明public、static的返回当前类对象的方法
25.         public static Bank getInstance(){
26.                
27.                 if(instance == null){               
28.                         instance = new Bank();       
29.                 }
30.                 return instance;
31.         }
32. }

复制代码

21.3 饿汉式和懒汉式

• 饿汉式：
  
  
  
  • 坏处：对象加载时间过长。
    
  • 好处：饿汉式是线程安全的。
    
  
  
• 懒汉式：
  
  
  
  • 好处：延迟对象的创建。
    
  
  
  
  
  • 1.      上述的写法坏处：线程不安全。（后面再修改）

    复制代码
  
  

21.4 单例模式应用场景

• 网站的计数器，一般也是单例模式实现，否则难以同步。
  
• 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志 文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
  
• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
  
• 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
  
• Application 也是单例的典型应用 。
  
• Windows的Task Manager (任务管理器)就是很典型的单例模式
  
• Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
  

二十二、类的成员之四——代码块（初始化代码块）

• 代码块的作用：用来初始化类、对象。
  
• 代码块如果有修饰的话，只能使用static。
  
• 分类：静态代码块和非静态代码块。
  

22.1 静态代码块

• 内部可以有输出语句。
  
• 随着类的加载而执行,而且只执行一次。
  
• 作用：初始化类的信息。
  
• 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行。
  
• 静态代码块的执行要优先于非静态代码块的执行。
  
• 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构。
  

22.2 非静态代码块

• 内部可以有输出语句。
  
• 随着对象的创建而执行。
  
• 每创建一个对象，就执行一次非静态代码块。
  
• 作用：可以在创建对象时，对对象的属性等进行初始化。
  
• 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行。
  
• 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。
  

22.3 例子

1. class Root{
2.         static{
3.                 System.out.println("Root的静态初始化块");
4.         }
5.         {
6.                 System.out.println("Root的普通初始化块");
7.         }
8.         public Root(){
9.                 super();
10.                 System.out.println("Root的无参数的构造器");
11.         }
12. }
14. class Mid extends Root{
15.         static{
16.                 System.out.println("Mid的静态初始化块");
17.         }
18.         {
19.                 System.out.println("Mid的普通初始化块");
20.         }
21.         public Mid(){
22.                 super();
23.                 System.out.println("Mid的无参数的构造器");
24.         }
25.         public Mid(String msg){
26.                 //通过this调用同一类中重载的构造器
27.                 this();
28.                 System.out.println("Mid的带参数构造器，其参数值："
29.                         + msg);
30.         }
31. }
33. class Leaf extends Mid{
34.         static{
35.                 System.out.println("Leaf的静态初始化块");
36.         }
37.         {
38.                 System.out.println("Leaf的普通初始化块");
39.         }       
40.         public Leaf(){
41.                 //通过super调用父类中有一个字符串参数的构造器
42.                 super("小钊");
43.                 System.out.println("Leaf的构造器");
44.         }
45. }
47. public class LeafTest{
48.         public static void main(String[] args){
49.                 new Leaf();
50.                 System.out.println();
51.                 new Leaf();
52.         }
53. }
55. /*        output：
56.         Root的静态初始化块
57.         Mid的静态初始化块
58.     Leaf的静态初始化块
59.     Root的普通初始化块
60.     Root的无参数的构造器
61.     Mid的普通初始化块
62.     Mid的无参数的构造器
63.     Mid的带参数构造器，其参数值：尚硅谷
64.     Leaf的普通初始化块
65.     Leaf的构造器
67.     Root的普通初始化块
68.     Root的无参数的构造器
69.     Mid的普通初始化块
70.     Mid的无参数的构造器
71.     Mid的带参数构造器，其参数值：尚硅谷
72.     Leaf的普通初始化块
73.         Leaf的构造器
75. */

复制代码

22.4 属性赋值的先后顺序

对属性可以赋值的位置：
① 默认初始化
② 显式初始化 / ⑤在代码块中赋值
③ 构造器中初始化
④ 有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
执行的先后顺序：① - ② / ⑤ - ③ - ④
其中，② 和 ⑤ 的先后顺序决定了其赋值的先后顺序。
例子：

1. public class OrderTest {
2.         public static void main(String[] args) {
3.                 Order order = new Order();
4.                 System.out.println(order.orderId);
5.         }
6. }
8. class Order{
9.        
10.         int orderId = 3;
11.         {
12.                 orderId = 4;
13.         }
14.                
15. }
16. //        output：
17. //        4

复制代码

1. public class OrderTest {
2.         public static void main(String[] args) {
3.                 Order order = new Order();
4.                 System.out.println(order.orderId);
5.         }
6. }
8. class Order{
9.        
10.         {
11.                 orderId = 4;
12.         }
13.    
14.     int orderId = 3;
15.                
16. }
17. //        output：
18. //        3

复制代码

注意：一般情况下，代码块写在属性定义之后。
二十三、final 关键字

• final 可以用来修饰的结构：类、方法、变量。
  
• final 用来修饰一个类：此类不能被其他类所继承。比如：String类、System类、StringBuffer类。
  
• final 用来修饰方法：表明此方法不可以被重写。比如：Object 类中 getClass();
  
• final 用来修饰变量：此时的"变量"就称为是一个常量。
  （1）final 修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化。
  （2）final 修饰局部变量： 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
  
• static final 用来修饰属性：全局常量。
  

1. // 例子一：
2. public class Something {
3.         public int addOne(final int x) {
4.                 //return ++x;    编译器报错，x值不能再变
5.                 return x + 1;        // x 没被重新赋值，正确
6.         }
7. }
9. //例子2：
10. public class Something {
11.         public static void main(String[] args) {
12.         Other o = new Other();
13.         new Something().addOne(o);
14.         }
15. public void addOne(final Other o) {
16.         // o = new Other();        报错
17.         o.i++;        //实例 o 里的变量可以改变，正确
18.         }
19. }
21. class Other {
22.         public int i;
23. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！