初始化及单例模式
- java-初始化及单例模式0601
- 前言
- 一、 初始化
- 0.0 基础的概念
- 0.1基本类型
- 0.2 转义字符
- 0.3 this关键字
- this 在构造方法的使用
- this 在多次调用方法的使用
- this 在多个构造方法之间调用的使用
- 0.4基础的代码
- 1.1 定义初始化
- 1.2 构造器(构造方法)初始化
- 1.3 方法重载
- 1.4 访问修饰符
- 1.5 set get 方法
- 二、单例模式与封装
- 2.1 基本概念
- 2.1.1模式简介:
- 2.1.2代码表达单列模式结构:
- 2.1.3完整的程序代码:
- 2.2 实例1-身份证号码
- 三、参考文献
前言
两部分内容:
1.初始化部分
2.单例模式
一、 初始化 0.0 基础的概念 0.1基本类型
1.java 8种基本类型 六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。
boolean:
- 只有两个取值:true 和 false
- 默认值false
- 例子 boolean b= true;
char:
- char 类型是一个单一的 16 位 Unicode 字符;
- char 数据类型可以储存任何字符;
- 例子:char letter = ‘A’;
整形:
byte:
- 最小值是 -128(-2^7);
- 最大值是 127(2^7-1);
- 例子:byte a = 100,byte b = -50。
short:
- 例子:short s = 1000,short r = -20000
- 最小值是 -32768(-2^15);
- 最大值是 32767(2^15 - 1);
int
- 最小值是 -2,147,483,648(-2^31;
- 最大值是 2,147,483,647(2^31 - 1);
- 例子:int a = 100000, int b = -200000。
long:
- 最小值是 -9,223,372,036,854,775,808(-2^63);
- 最大值是 9,223,372,036,854,775,807(2^63 -1);
- 这种类型主要使用在需要比较大整数的系统上;
- 默认值是 0L;
- 例子: long a = 100000L,long b = -200000L。
浮点:
float:
- float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;
- 例子:float f1 = 234.5f。
double:
- double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数;
浮点数的默认类型为 double 类型;
this指代当前类的对象,this.name 当前类的name ,等于name的name代表输入的name参数
// 创建构造方法,为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {
this.name = name; // 设置教师名称
this.salary = salary; // 设置教师工资
this.age = age; // 设置教师年龄
}
this 在多次调用方法的使用
定义一个当前类的方法,返回当前类的指针,return this ,那么你在每次使用这个方法的时候都会返回这个类的对象,那么又可以去调用方法,实现多次调用
public class Leaf {
int i=0;
//increment 方法 返回Leaf类
Leaf increment() {
i++;
return this;//调用 increment 返回 this 当前类的对象 ,也就是返回了Leaf类的对象
}
void print() {
System.out.println(i);
}
public static void main(String[] args) {
Leaf leaf=new Leaf();
//反复调用操作
leaf.increment().increment().increment().print();
}
}
output:3
this 在多个构造方法之间调用的使用
为了在一个构造器A可以使用另外一个构造器B不发生混乱
值得注意的是:this()要放到最前面,并且只能用一次,这个的意思就是把参数输入B构造器,执行B构造器代码,执行完毕回来执行A
基本构造:
类(参数1){}
类(参数2){this(参数一)}
代码思路是:
4个构造方法解释Flower类,
首先看主函数,调用构造方法4(因为没有传参数,所以是构造方法4),
4调用构造方法三,
三调用构造方法一,执行构造方法一,此时petals为47,
接着执行完构造方法三 输出String
再去执行构造方法四,输出default,
再执行打印函数
public class Flower {
//基本参数
int petalCount=0;
String s="initial value";
//构造方法1
Flower(int petals){
petalCount=petals;
System.out.println("Constructor petalCount"+petalCount);
}
//构造方法2
Flower(String ss){
System.out.println("Constructor"+ss);
s=ss;
}
//构造方法3 两个this的使用
Flower(String s,int petals){
this(petals); //把petals输入构造方法1中
this.s=s; //这里是自己当前的构造方法
System.out.println("String");
}
//构造方法4
Flower(){
this("hi",47); //调用构造方法3
System.out.println("default");
}
//打印的方法
void printetalCount() {
System.out.println("petalCount"+petalCount+"S="+s);
}
//主程序
public static void main(String[] args) {
Flower fl=new Flower();
fl.printetalCount();
}
}
output:
Constructor petalCount47
String
default
petalCount47S=hi
0.4基础的代码
system.err.println() //输出为红色字体 sysrem.out.println() //我们的正常输出1.1 定义初始化
1.思路一:直接赋予初值
public static InitialValuses{
int i
}
2.思路二:创建类对象也是定义初始化
Depth deep=new Depth();
- 调用方法提供初始值:
int i =f() // f中有 int 的返回值1.2 构造器(构造方法)初始化
1.但是通常我们一般用 private 修饰 定义初始化,这样其他类就无法获取这个属性。因此我们在别的类中对该类设置参数的初始化时,往往采用构造初始化。
2.构造方法:
- 格式: 以类名为方法名
- 每个类都具有一个隐式的空参数构造方法,在显式的写了构造方法之后会被覆盖掉 //默认构造器
- 构造方法是 创建对象时调用的(对于每个对象,构造方法只能执行一次)
- 构造方法可以自己添加参数 在创建对象时直接初始化好// 含参构造器和不含参数构造器
3.例如:
1)你在 User类中属性全部用private 修饰,那么你在Mangage是无法修改参数的,如下的代码是一定会报错的
user.name="zh";
2)因此我们采用了构造器,那么在我初始化的时候就可以输入参数
public class Mangage {
public static void main(String[] args) {
//下面这个代码
User user=new User("张三", 18, "01", "12345678989");
}
}
class User {
//属性 不希望外部获取进行封装
private String name;
private int age;
private String id;
private String phonnum;
//不含参数构造方法
public User() {
System.out.println("张嘉");
}
//含参数构造方法
public User(String name, int age, String id, String phonnum ) {
this.name=name;
this.age=age;
this.id=id;
if(phonnum.length()==11) {
this.phonnum=phonnum;
}else {
System.out.println("手机号码不正确");
}
}
}
4.构造器还有一种好处,this.name=name,当我需要进行判断时,或者进行某些操作,可以在此处调用set方法 , 比如 :
this.setname(name)
示例代码:
public class Manage2 {
public static void main(String[] args) {
User2 use=new User2("zyj",-5,"kkk","121556");
}
}
class User2{
//属性
private String name;
private int age;
private String id;
private String phonenum;
//构造方法
User2(String name, int age, String id, String phonenum){
this.name = name;
this.setAge (age);
this.id = id;
this.setPhonenum (phonenum);
}
//set方法
public void setAge(int age) {
if(age<0) {
System.err.println ("年龄不能小于0");
}else {
this.age=age;
}
}
public void setPhonenum(String phonenum) {
if(phonenum.length () == 11){
this.phonenum = phonenum;
} else{
System.err.println ("手机号码不正确");
}
}
}
output:
年龄不能小于0
手机号码不正确
1.3 方法重载
方法名字相同,形式参数不同称为方法重载
方法(){}
方法(参数){}
调用时:
对象.方法()
对象.方法(对应参数)
原因: 由于参数使用了private修饰,那么在不同的类中无法访问并且修改,我们前文提出了构造器的方法,但是构造器很难自由修改。因此为了便于修改,我们引入 set get is 方法
public void set(String name){this.name=name;} //改参数
public String get(){return name} //得到参数
二、单例模式与封装
2.1 基本概念
简而言之: 一个类3部分: 一个私有构造方法 一个私有静态对象 一个静态get方法获取指针
2.1.1模式简介:1.为了防止外部对其实例化,将构造方法设为私有
2.只包含一个类Singleton
3.内部定义了一个Singleton类型的静态对象,作为外部共享的唯一实例
4.提供一个静态的get方法,可以让用户使用//为什么是静态的方法,因为在public static void main 下面可以调用静态方法
public class User{
//私有构造方法
private User(参数){}
//唯一静态对象
private static User king=new User(参数)
}
//静态get方法
public static User getking(){
return king;
}
2.1.3完整的程序代码:
同时也涉及到了单例模式创建对象的改进,只有当我要用到对象的时候我再创建,下列创建了两个对象一个是传统单列模式,一个是改进的储存方法。
public class Manage2 {
public static void main(String[] args) {
User2 king1=User2.getKing();
User2 king2=User2.getKing2();
king1.setAge(50);
king2.setAge(300);
System.err.println(king1.getage());
System.err.println(king2.getage());
}
}
class User2{
//属性
private String name;
private int age;
private String id;
private String phonenum;
//私有构造方法
private User2(String name, int age, String id, String phonenum){
this.name = name;
this.age=age ;
this.id = id;
this.phonenum=phonenum;
}
//1.基本方法 私有静态对象和静态get方法
private static User2 king = new User2 ("king", 18, "123456789", "123456789");
public static User2 getKing() {
System.out.println("获取对象");
return king;
}
//2.改进方法-节省空间
private static User2 king2=null; //先创建空对象当要用了再get
public static User2 getKing2() {
//只新建一次,不然每次都新建就刷新了我的对象
if(king2==null) {
king2 = new User2 ("king", 18, "123456789", "123456789");
System.out.println("新建实例");
}
return king2;
}
//校验的方法-看是否获取了对象
public void setAge(int age){
if(age < 0){
System.err.println ("年龄不能小于0");
}
this.age = age;
}
public int getage() {
return age;
}
}
output:
获取对象
新建实例
50
300
上述操作在主程序可以直接使用 User.getking 获取对象,这就是静态方法的好处
2.2 实例1-身份证号码要实现什么:
1.一个人只有一个身份证号码
2.第一次申请分配一个身份证号码,当遗失了补办的时候,仍然是原来的身份证号码
用到的新的方法:
生成一个三位数,注意看文档
import java.util.Random;
public class Client {
public static void main(String[] args) {
IdentityCardNo no1=IdentityCardNo.getID(); //类加方法直接调用,静态方法好处,返回对象
IdentityCardNo no2=IdentityCardNo.getID();
System.out.println("身份证号码是否一致"+(no1==no2));
//有了对象可以去调用方法
String str1=no1.getIdentityCardNo();
String str2=no2.getIdentityCardNo();
System.out.println("第一次号码"+str1);
System.out.println("第二次号码"+str2);
System.out.println("内容是否相同"+str1.equals(str2));
System.out.println("是否相同对象"+(str1==str2));
}
}
class IdentityCardNo{
//私有的静态对象 创建空对象,直到get时
private static IdentityCardNo instance =null;
private String no;
//私有的构造方法
private IdentityCardNo() {
}
//public 静态 get方法
public static IdentityCardNo getID() {
if(instance==null) {
System.out.println("第一次办理身份证,分配新号码");
instance=new IdentityCardNo();
//设置一个card no
Random random=new Random();
int randomid=random.nextInt(900)+100;
//nextint 生成 0 a 内的随机数
//生成3位数方法 100-1000 0+100-900+100
//nextint(900)+100
String randomidk = "no" +randomid; //转为字符串类型
instance.setIdentityCardNo(randomidk);
}else {
System.out.println("重复办理身份证,获取旧号码");
}
return instance;
}
public void setIdentityCardNo(String no) {
this.no=no;
}
public String getIdentityCardNo() {
return no;
}
}
output
第一次办理身份证,分配新号码
重复办理身份证,获取旧号码
身份证号码是否一致true
第一次号码no839
第二次号码no839
内容是否相同true
是否相同对象true
三、参考文献
1.Thinking in Java,version 4, Chapter 5.(P 77-P 108)
2.设计模式,第二版,清华大学出版社,Chapter 9(P 136-P 147)刘伟主编



