常用类和反射

StringBuffter类

线程安全，可变字符串。字符串缓冲区就像一个String 但是可以修改，在任何时间点，它包含一些特定字符序列，但是可以通过某些来更改序列长度和内容。
2 StringBuilder（线程不安全的） 比StringBuffer（线程安全的）快  比String  快

开发中遇到的String类型的数据偏多吗，所以用String用的比较多

package com.qfedu.a_stringbuffer;

public class Demo1 {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("start");//默认缓冲区的容量为16
		System.out.println(sb);//字符串的缓冲区  在堆区
		sb.append("top");//在后面追加
		System.out.println(sb);//是一个区域，随时可以向里面添加 的
		//start  字符串和  starttop这个字符字符串在同一个内存地址里面
		//如果是string  拼接字符串的话，他们不再同一个内存地址里面
		sb.insert(3, "大");//在某一个位置插入一个数据
		System.out.println(sb);//sta大rttop
		//....
		sb.delete(2, 4);//  a大删除了   包含2  不包含4  要头不要尾
		System.out.println(sb);
		//咱们这个里面也牵涉到扩容
		//确保最小瓶的容量。这个人家默认的是16  最低确保容量4567  
		//据意味着你要在内存开辟空间是耗内存的
		sb.ensureCapacity(4567);//确保最低的容量
		System.out.println(sb.length());//返回字符串的长度		
	}
}

枚举类

- Java中枚举类是一个特殊的类，一般是表示一组常量，一年的4个季节。一年12个月份。一个星期有7天。方向东西南北等

- public  static   final  int  a = 20;java 声明常量的方式

- 可以使用枚举代替常量

package com.qfedu.a_stringbuffer;

enum Week {
	MON,TUE, WEN,THUR,FRI,SAT,SUN
}
public class Demo3 {
	public static void main(String[] args) {
		//把它想象成静态的final的类下面的属性  类名.属性  
		printWeek(Week.FRI);
       
	}
	public static void printWeek(Week week) {
		switch (week) {
		case MON:
			System.out.println("星期一");
			break;
		case TUE:
			System.out.println("星期2");
			break;
		case WEN:
			System.out.println("星期3");
			break;
		case THUR:
			System.out.println("星期4");
			break;
		case FRI:
			System.out.println("星期5");
			break;
		case SAT:
			System.out.println("星期6");
			break;
		case SUN:
			System.out.println("星期7");
			break;
		default:
			break;
		}
	}

}

包装类

- ​	1.JDK1.5之后有装箱和拆箱之说

- ​				装箱：将基本数据类型转为包装类对象

- ​				拆箱：将包装类对象转为基本数据类型

- 2.***Value();将包装类对象转为基本数据类型的

- 3.parse****();将字符串转为基本数据类型【重点开发要用！！！】

- 4.valueOf();将基本数据类型转为包装类【开发中也会用】

package com.qfedu.a_stringbuffer;

public class Demo5 {
	public static void main(String[] args) {
		byte a = (byte)20;//20 int 类型的数据->byte 大转小，但是javajdk1.5之后自动转了
		Byte a1 = 20; //进行自动装箱的过程  将基本数据类型转为包装类对象
		Byte byte1 = new Byte((byte)20);//将基本数据类型转为包装类
		System.out.println(a1);
		System.out.println(byte1);
		
		Integer integer = new Integer(250);
		int int1 = integer;//自动拆箱  将包装类对象转为基本数据类型
		System.out.println(int1);
		Character c1Character = 'A';//装箱
		Boolean  boolean1= true;
		
		//将包装类对象转为基本数据类型的方法  ***Value()
		Integer integer2 = new Integer(34);
		int int2 = integer2.intValue();//返回值是int 类型的数据
		System.out.println(int2);
		Short short1  = new Short((short)45);
		short  short2 = short1.shortValue();
		System.out.println(short2);
		
		int v2 = Integer.parseInt("89");//开发要用  数字字符串
		System.out.println(v2);//int类型的89
		
		//一般如果怕精度丢失的的话，先用字符串来表示，然后再转为double
		double d2 = Double.parseDouble("89.99999");
		System.out.println(d2);
		
		byte byte4 = 45;
		Byte b4 = Byte.valueOf(byte4);//将 基本数据类型转为包装类
		System.out.println(b4);
		
		
	}

}

Math类

Math中全部是静态方法 可以使用类.方法进行调用

绝对值，最大值，最小值，向上取整，取整，随机数，四舍五入

package com.qfedu.d_math;

import java.util.Arrays;

public class Demo1 {
	public static void main(String[] args) {
		System.out.println(Math.abs(-9.8));//绝对值
		System.out.println(Math.max(1, 2));//最大值
		System.out.println(Math.min(3, 5));//最小值
		//求三个及三个以上数的最大值
		System.out.println(Math.max(Math.max(3, 4), 5));
		//要百十个的话比较大小的话，就循环吧
		//面试不会用砸门现在学的常用类的方法
		System.out.println(Math.ceil(3.4));//向上取整  4.0
		System.out.println(Math.floor(5.6));//向下取整 5.0
		System.out.println(Math.round(4.5));//四舍五入  5
		System.out.println(Math.random());//[0, 1) 包含0 不包含1的随机数
		//random()   返回值是double类型的数据
		//随机出来0~100直接的整数

		System.out.println((int)(Math.random() * 100));
	}

}

Random类

package com.qfedu.e_random;

import java.util.Random;

public class Demo1 {
	public static void main(String[] args) {
		Random random = new Random();
		System.out.println(random);
		System.out.println(random.nextBoolean());//随机生成一个布尔类型的数据
		System.out.println(random.nextInt());//随机生成一个整型的数据
		System.out.println(random.nextFloat());//
		System.out.println(random.nextDouble());
		//100种子   是啥意思？
		Random random1 = new Random(100);
		System.out.println(random1);
		System.out.println(random1.nextInt());
	}

}

Runtime类

package com.qfedu.g_runtime;

import java.io.IOException;

public class Demo1 {
	public static void main(String[] args) throws IOException {
		Runtime runtime = Runtime.getRuntime();
		
		System.out.println(runtime.maxMemory()/1024/1024);// 1027866624  单位是字节Java虚拟机将尝试使用的最大内存量。 
		System.out.println(runtime.freeMemory()/1024/1024);//空闲内存  
		
		//在咱们电脑中打开一个软件，双击这个软件，还可以通过java代码来软件
		runtime.exec("C:\\Program Files (x86)\\Notepad++\\notepad++.exe");
	}

}

Date类

package com.qfedu.h_date;

import java.util.Date;

public class Demo1 {
	public static void main(String[] args) {
		Date date = new Date();
		System.out.println(date);
		System.out.println(date.getYear() + 1900);
		System.out.println(date.getMonth() + 1);
		System.out.println(date.getDay());//3代表星期几
		System.out.println(date.getHours());//获取小时
		
	}

}

Calendar类

package com.qfedu.h_date;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Demo2 {
	public static void main(String[] args) {
		Calendar calendar = Calendar.getInstance();
        //通过get方法获取系统默认的一个常量   Year
		System.out.println(calendar.get(Calendar.YEAR));//年
		System.out.println(calendar.get(Calendar.MONTH));//月  月份从1开始
		System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//获取当月的第几天
		System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
		System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
		System.out.println(calendar.get(Calendar.HOUR));
		System.out.println(calendar.get(Calendar.MINUTE));
		System.out.println(calendar.get(Calendar.SECOND));
	
		//获取当前时间
		Date time = calendar.getTime();
		System.out.println(time);
		//Wed Jan 12 15:52:33 CST 2022 这个时间不太友好  对咱们中国人不太友好
		//格式当前的时间吗，把它变成中国人能看懂的时间
		//M  代表的是月份  m代表的是分钟  y代表年份 d代表的是一个月里面的第几天 
		//SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		System.out.println(sdf.format(time));
		//2022-01-12 15:56:38  以后开发那就用这个
		
	}

}

第二章 反射

java反射机制概述

反射被视为动态语言的关键，反射机制允许在程序运行期间可以获取任何类的信息，并直接操纵任意对象属性和方法

加载完类之后，在堆内存的方法区中产生一个class类型的对象，这个对象就包含完整类的信息结构

java反射提供的功能

在运行是判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判断任意一个类所具有成员变量和方法

在运行时获取泛型信息

在运行时任意调用一类的成员变量和方法

在运行时处理注解

可以生成代理模式

关于java.lang.Class的理解

 类的加载过程：

  程序经过javac.exe进行编译，生成一个或者多个字节码文件(.class)，然后在使用java进行命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。这个过程叫类的加载。

然后将加载到内存中的类，叫做运行时的类，就称为Class的一个实例。

获取Class实例的方式

- 类.class；
- 对象.getClass
- Class.forName("类的全路径名称")

package com.mmc.classCreate;

/**
 * 三种方式获取Class；
 * 运行时的类会在内存中，缓冲一段时间，我们可以通过不同方式来获取运行时的类
 */
public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        // 方式一
        Class aClass = Student.class;
        System.out.println(aClass);
        System.out.println("------------");
        //方式二
        Student student = new Student();
        Class aClass1 = student.getClass();
        System.out.println(aClass1);
        System.out.println("----------------");
        //方式三
        Class aClass2 = Class.forName("com.mmc.classCreate.Student");
        System.out.println(aClass2);
        System.out.println(aClass==aClass1);
        System.out.println(aClass2==aClass1);
        //方式四 通过类的加载器classLoader(了解)
        ClassLoader classLoader = ClassTest.class.getClassLoader();
        Class aClass3 = classLoader.loadClass("com.mmc.classCreate.Student");
        System.out.println(aClass3);
    }
}
class Student{

}

获取Constructor类对象

这个Constructor这类是反射所对应的构造方法的一个类对象

描述构造方法

Constructor[]   getConstructors();

​			获取当前类下面的所有的非私有化的构造方法

Constructor[]   getDeclaredConstructors();

​			获取当前类下面的所有的构造方法

Constructor getConstructor(Class ...parameterType);

​			获取一个非私有化的构造方法

Constructor getDeclaredConstructor(Class ...parameterType);

​			获取一个私有化的构造方法

以上的方法是Class调用的

下面这个方法Constructor对象调用的

Object   newInstance();通过constructor对象创建出来一个对象

获取Menthod类对象

Method []   getMethods();

​	 获取当前.class文件下面的public修饰的方法，和父类的公开的方法

Method[]  getDeclaredMethods();

​		获取当前.class文件下面的public修饰以及private的方法，父类继承的方法获取不了

获取Filed类对象

Field[]   getFields();

​		获取public 修饰的属性

Field[]   getDeclaredFields();

​		获取私有的属性

Filed  getField(String name);

​		通过属性的名字获取属性对象

类加载器的作用

- 将class字节码文件内容加载到内存中，并将这些静态数据转换为方法区运行时数据，然后在堆中生成一个代表运行时类的Class对象。
- 内缓存：一旦某个类被加载到类加载器中，它将缓存一段时间。不过jvm垃圾回收这些Class对象 

getFile 和getDeclaredFiled区别

getFile 只能获取public的，包括父类继承的字段

getDeclaredFiled 可以获取本类所有字段，包括private 但是不能获取继承来的字段。但是不能访问private字段的值 除非加一个setAccessible设置为true。

代理模式

动态代理和静态代理

静态代理

package com.mmc.staticproxy;
//实现静态代理 为啥叫静态代理 因为定义代理类都被定义死了
public interface HouseProxy {
    public void rend();
}
//实现类 代理类和被代理类
//------------------------------
package com.mmc.staticproxy;
//被代理类
public class AgencyProxy implements HouseProxy {
    private HouseProxy houseProxy;
    public AgencyProxy(HouseProxy houseProxy){
        this.houseProxy=houseProxy;
    }
    @Override
    public void rend() {
        System.out.println("中介找房子");
        houseProxy.rend();
        System.out.println("租房成功，签合同");
    }
}
//---------------------------------------------
package com.mmc.staticproxy;

//代理类
public class HosdProxy implements HouseProxy {

    @Override
    public void rend() {
        System.out.println("客户租房子");
    }
}
//-----------------------------------
package com.mmc.staticproxy;
//test类
public class ProxyTest {
    public static void main(String[] args) {
        //创建代理类
        HouseProxy hosdProxy = new HosdProxy();
        //创建被代理类
        HouseProxy agencyProxy = new AgencyProxy(hosdProxy);
        agencyProxy.rend();
    }
}