首页 > 代码库 > 面向对象：封装（二）：包的使用；静态成员；单例模式案例

面向对象：封装（二）：包的使用；静态成员；单例模式案例

2024-08-29 12:33:36   219人阅读

约定：类名，首字母要大写，如果多个单词组成，每个首 字母都大写，其余的字母小写。

　　   常量名，每个字母都大写。

  　　一：包的概念：创建，使用。

1.新建包：

最上面一行，之前不能再有其它代码了。

package 包名;

注意：包名一般都有命名的规范。例如：com.itnba.maya.zza

2.使用包：

import 包名.*;

import 包名.类名;

例如：import com.itnba.maya.ccz.*;

注意：import不要放在package的上面上

　　　　二：常量

常量。 final型变量 不是：const,readonly

Java中没有真正的常量。只有final型的变量，可以当常量来用。

final型变量，只有两个地方可以赋值，其余的地方是不能放在=左边的：

1.再定义的时候可以赋值。

2.再购造函数中可以赋值，如果在定义是赋值了，则在构造函数中不能赋值。包括定义时赋了null的值，则在构造函数中也不能赋值。

　　　　三：静态成员：（关键字：static，与“静态”相对应的叫“实例”）

静态成员包括：静态变量和静态方法。与之对应的是，实例变量和实例方法。

1.实例变量与实例方法是属于每个单个对象的。静态变量与静态方法是属于所有对象共享的，即属

类的。

2.静态方法内只能操作当前类的静态变量和静态方法，不能操作实例变量和实例方法。实例方法中可以调用当前类的静态变量和静态方法。

package com.inba.maya.zzb;

public class Bao2 {
    public final String AAA="666";
    private String name;
    private final String sex;
    public static String zhuRen;
    
    public static String getZhuren() {
        setName("6546");
        return zhuRen;
    }

    public static void setZhuren(String zhuren) {
        Bao2.zhuRen = zhuren;
    }

    public Bao2(){
        sex="nv";
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}
/*
在这两端代码中当用对象名调用getzhuren时，因为getzhuren方法（静态的）中有setname方法（实例的），因为对象在hipe空间中共享了静态的getzhuren方法，所以可以调用，
并且setname也是实例的所以可以调用。
*/

/*
但是当我用类名来调用getzhuren时，因为getzhuren方法（静态的）中有setname方法（实例的），当hipe空间中不止一个name时不能确定是哪一个对象来调用setname的所以不能调用
*/

package com.inba.maya.zza;

import com.inba.maya.zzb.*;

public class Bao1 {

    public static void main(String[] args) {
        Bao2 b21=new Bao2();
        Bao2 b22=new Bao2();
        b21.setZhuren("张三");
        System.out.println(b21.getZhuren());
        b22.setZhuren("李四");
        System.out.println(b22.getZhuren());
        System.out.println(b21.getZhuren());
        
        Bao2.getZhuren();
        b21.getZhuren();
        System.out.println(b21.getZhuren());

    }

}

单例模式案例

package com.inba.maya.zzb;

public class Bao3 {
    String age;
　　//做一个当前类型的静态的成员变量
    private static Bao3 nl;
　　//把构造函数设为private
    private Bao3(){
        age="18";
    }
　　//做一个public的静态成员方法。用来给第二步中的成员变量实例化，并返回回去
    public static Bao3 bao(){
        if(nl==null){
            nl=new Bao3();
        }
        return nl;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
}

Bao3 b1=Bao3.bao();
System.out.println(b1.getAge());

Bao3 b2=Bao3.bao();
System.out.println();

当我调用时b2不会再new出一个bao（），b1，b2指向的是同一个bao（）

单类模式。单例模式。只能生成一个对象。---案例。private 构造函数。静态方法。

第一步：把构造函数设为private。

第二步：做一个当前类型的静态的成员变量。

第三步：做一个public的静态成员方法。用来给第二步中的成员变量实例化，并返回回去。

面向对象：封装（二）：包的使用；静态成员；单例模式案例


联系
我们