杰神之Java中的单例,权限修饰符和基本数据包装类的应用

单例

一种设计模式

核心思想:在整个程序执行期间 有且只有一个该类的对象存在

* 好处

它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用

* 如何去保证 程序中有且只有一个对象?

1.不让外界来创建对象

2.这个对象我来创建(也不能让外界访问)

3.需要开放访问这个对象的方法

//饿汉式 单例
class Single {
//创建单例对象
//随着类的加载而创建
private static Single single =new Single();
//构造方法私有化
private Single(){

}
//开放一个访问对象的方法
public static Single getInstance() {
return single;
}
}
//懒汉式 单例(只有你调用获取对象的方法才有可能去创建对象)
//延迟加载(懒加载)
class SingleLan{
private static SingleLan singleLan =null;
private SingleLan() {

}
//获取单例对象的方法
public static SingleLan getInstance() {
if (singleLan == null) {
singleLan =new SingleLan();
}
return singleLan;
}
}

StringBuffer和StringBuilder

特点:

1.StringBuffer 相当于一个可变的序列(操作的是原字符串) 2.是线程安全(耗费资源)

方法
* 1.拼接
* 2.插入
* 3.删除
* 4.反转
* 5.替换
* 6.String与StringBuffer的相互转换
public static void main(String[] args) {
//fun1();
//fun2();
//fun3();
//fun4();
//fun6();
fun5();

}
public static void fun5() {
//替换
StringBuffer sb =new StringBuffer();
sb.append("wanglong");
sb.replace(0, 4, "li");
System.out.println(sb);
//字符串截取 返回了一个新的字符串给你
//      String substring =sb.substring(4);
//      System.out.println(substring);
String substring = sb.substring(0,4);
System.out.println(substring);
}
public static void fun6() {
/*
* 需求
* 把int[] array = new int[]{1,2,3,4};
* 输出上面的  [1, 2, 3, 4]
* 要求:使用两种方法(String 和 StringBuffer)
*/
//使用字符串实现
int[] array =new int[] {1,2,3,4};
String string = "[";
//遍历数组
for (int i = 0; i < array.length; i++) {
string=string+array[i];
if (i!=array.length-1) {
string =string + ", ";
}
}
string =string+"]";
System.out.println(string);
//使用StringBuffer实现
StringBuffer stringBuffer =new StringBuffer();
stringBuffer.append("[");
for (int i = 0; i < array.length; i++) {
stringBuffer.append(array[i]);
if (i!=array.length-1) {
stringBuffer.append( ", ");
}
}
stringBuffer.append("]");
System.out.println(stringBuffer);
}
public static void fun4() {
//从键盘输入一个字符串 反转
System.out.println("请输入一个字符串");
Scanner sc =new Scanner(System.in);
String string =sc.nextLine();
//转成StringBuffer
StringBuffer stringBuffer =new StringBuffer(string);
stringBuffer.reverse();
//转化成字符串
System.out.println(stringBuffer.toString());
sc.close();
}
public static void fun3() {
StringBuffer sb = new StringBuffer();
sb.append("wanglong");
//删除
//sb.delete(0, 0);
//注意:开始坐标不能越界,结束越界系统当清空处理
System.out.println(sb);
//删除字符
sb.deleteCharAt(0);
System.out.println(sb);
//反转
sb.reverse();
System.out.println(sb);
}
public static void fun2() {
//直接使用字符串创建StringBuffer
StringBuffer sb =new StringBuffer("wanglong");
//插入一个字符 把字符插入索引的位置上
//插入boolean类型就相当于把true/false当字符串插入
sb.insert(3, 'a');
System.out.println(sb);
//给索引位置进行字符修改(替换)
sb.setCharAt(3, 'k');
//插入字符和字符修改的时候不能越界
//传入角标返回字符
char c = sb.charAt(7);
System.out.println(c);
//buffer转成字符数组
//先变成字符串再变成字符数组
char[] charArray=sb.toString().toCharArray();
System.out.println(charArray);
}
/**
* 无参创建StringBuffer
*/
public static void fun1() {
//创建一个StringBuffer(拼接字符串)
StringBuffer sb = new StringBuffer();
//获取容量(理论值)默认值 16
System.out.println(sb.capacity());
//获取长度
System.out.println(sb.length());
//转化为字符串
System.out.println(sb.toString());
//拼接字符串(操作的是原对象)
StringBuffer sb1 = sb.append("wanglong");
//如果直接打印对象,系统会帮你调用toString方法
System.out.println(sb);
System.out.println(sb1);
}

总结:

StringBuffer 和StringBulider区别

StringBuffer 线程安全 效率低(耗费系统资源)

StringBuilder 线程不安全 效率高

使用方法一样

String和StringBuffer的区别

String是不可变的,线程不安全

StringBuffer是可变的,操作的是对象本身

String和StringBuffer作为方法的参数的区别

字符串作为参数的事后,跟基本类型作为参数一样,相当于值的传递

StringBuffer作为参数传递的是地址

基本数据类型的包装类

/*
* 基本数据类型 包装类
* byte         Byte
* int          integer
* short            Short
* long         Long
* float            Float
* double       Double
* boolean      Boolean
* char         character
*
* 为什么要把基本数据类型 封装成一个类
* 在类中可以声明方法 可以使用对象调用方法
*/
public class Demo04 {
public static void main(String[] args) {
fun1();

fun2();
//传入的值 如果在-128到127之间
//返回的是数组中的一个地址
//否则返回的是新创建的对象
Integer num1 = 100;
Integer num2 = 100;
//比较的是地址
System.out.println(num1 == num2);
//Integer中的equail是方法,比较int值
System.out.println(num1.equals(num2));
}

public static void fun2() {
/*
* JDK1.5 自动装箱和自动拆箱
*/
// 这样声明相当于Integer.valueOf(10)
// 系统会帮自动装箱,调用这个方法
// 初值不要给null,避免计算中发生错误
Integer num1 = 10;
// 系统帮你把num1进行自动拆箱转换回了int类型
int rel = num1 + 5;
System.out.println(rel);
}

public static void fun1() {
// 创建一个integer对象
Integer integer1 = new Integer(10);
System.out.println(integer1);
// 把字符串转化成Integer类型
// 注意:是数字格式字符串才能转
Integer integer2 = new Integer("123");
System.out.println(integer2);

int a = 60;
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));

// int和Integer之间的转换 静态方法
Integer num1 = Integer.valueOf(10);
int num2 = num1.intValue();
System.out.println(num2);

// String 和integer之间的转换
Integer num3 = Integer.valueOf("100");
String string3 = num3.toString();
System.out.println(string3);
// 把字符串 转换成int
}
}

权限修饰符