栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【java-初始化及单例模式0601】

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【java-初始化及单例模式0601】

java-初始化及单例模式0601

初始化及单例模式
  • 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 类型;
0.2 转义字符

0.3 this关键字 this 在构造方法的使用

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();	
  1. 调用方法提供初始值:
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 方法重载

方法名字相同,形式参数不同称为方法重载
方法(){}
方法(参数){}

调用时:
对象.方法()
对象.方法(对应参数)

1.4 访问修饰符

1.5 set get 方法

原因: 由于参数使用了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 下面可以调用静态方法

2.1.2代码表达单列模式结构:
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)刘伟主编

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/943230.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号