Day15 Java 学习笔记

目录

常用工具类

Math类

 Random类

 SecureRandom类

 小结

 内部类

普通类内部类

匿名内部类

 静态内部类

 小结

---

常用工具类

Math类

System.out.println(Math.PI);// PI 3.141592653589793
		System.out.println(Math.abs(-100));// 取绝对值 100
		System.out.println(Math.pow(3, 2));//3的2次方 9.0
		System.out.println(Math.sqrt(4));//开根号 2.0
		System.out.println(Math.max(3, 4.0));//取最大值 4.0
		System.out.println(Math.min(3, 4.0));//取最小值 3.0
		System.out.println(Math.random());// [0,1)的随机数字
		System.out.println((int) (Math.random() * 80 + 20));
		// 弧度 = 角度*(pi/180)
		// 角度 = 弧度/(pi/180)
		System.out.println(Math.sin(90 * (Math.PI / 180)));//1.0
		System.out.println(Math.cos(0 * (Math.PI / 180)));//1.0
		System.out.println(Math.tan(45 * (Math.PI / 180)));

		// 实现方法的重载 注意传参和返回值
		long a = Math.round(3.25);//返回long
		int b = Math.round(3.25f);//返回int
		System.out.println(a);//3
		System.out.println(b);//3

 Random类

Random用来创建伪随机数。所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的。要生成一个随机数，可以使用nextInt()、nextLong()、nextFloat()、nextDouble()：

Random r = new Random();
r.nextInt(); // 每次都不一样
r.nextInt(10); // 生成一个[0,10)之间的int
r.nextLong(); // 每次都不一样
r.nextFloat(); // 生成一个[0,1)之间的float
r.nextDouble(); // 生成一个[0,1)之间的double

//Random是一个伪随机数 如果种子一样 则随机的序列一样
		//如果不给定种子，就使用系统当前时间戳作为种子
		Random r1 =new Random();
		Random r2 =new Random();

		for (int i = 0; i < 10; i++) {
			System.out.print(r1.nextInt(20)+" ");
		}
		System.out.println();
		for (int i = 0; i < 10; i++) {
			System.out.print(r2.nextInt(20)+" ");

 SecureRandom类

 实际上真正的真随机数只能通过量子力学原理来获取，而我们想要的是一个不可预测的安全的随机数，SecureRandom就是用来创建安全的随机数的：

//真随机 结果不可预测
		SecureRandom sr = new SecureRandom();
		//随机对象获取随机整数 浮点数 布尔等
		System.out.println(sr.nextInt());
		System.out.println(sr.nextInt(200));
		System.out.println(sr.nextDouble());
		System.out.println(sr.nextBoolean());

SecureRandom sr = null;
		try {
			//获取等级更高的随机数	但可能会有异常
			sr = SecureRandom.getInstanceStrong();
		} catch (NoSuchAlgorithmException e) {
			//如果出现异常 使用new的方式创建一个随机数
			sr = new SecureRandom();
		}

 小结

●Math：数学计算
●Random：生成伪随机数
●SecureRandom：生成安全的随机数

 内部类

一个内部类的定义是定义在另一个类的内部

普通类内部类

修饰符 class Outer{
成员变量,成员常量,普通方法,构造方法,静态常量,静态代码块,代码块;
    class Inner{
        不能有static存在(静态常量除外),依附于外部类存在
      内部类对象也必须要依附于外部类对象存在
    }
}

package apesource.knowledge03.内部类;


public class Outer {
	private String name = "张三";
	public static final int VALUE = 19;
	static {
		System.out.println("这个是Outer的静态代码块");
	}
	{
		System.out.println("这个是Outer的构造代码块");
	}

	public Outer() {
		System.out.println("这个是Outer的构造方法");
	}

	public void todo() {
		System.out.println("这个是Outer的todo方法");
	}
	public static void test01() {
		System.out.println("这个是Outer的静态方法");
	}
	

	class Inner {
		private String name = "李子";
		public static final int AGE = 10;
//		不能有静态的变量,静态的方法,静态代码块
//		public static int a;
//		static {
//			System.out.println("这个是内部类的静态代码块");
//		}
		
		{
			System.out.println("这个是内部类的构造代码块");
		}

		public Inner() {
			System.out.println("这个是内部的构造方法");
		}
		
		public void todo() {
			System.out.println("这个是内部类的普通方法");
		}


		// 优先级:局部>成员
		// 通过"this"关键字调用内部类自己的成员变量或者方法
		// 通过"外部类.this"调用外部类的成员变量或者方法
		public void sayHello(String name) {
			System.out.println("局部变量name" + name);
			System.out.println("内部类成员变量name" + this.name);
			System.out.println("外部类成员变量name" + Outer.this.name);
            System.out.println(VALUE);
            test01();
            Outer.this.todo();
		}
	}
}

两种方式创建对象:

	//方式1
		//1.创建外部类对象
//		Outer outer = new Outer();
//		//2.依靠外部类创建内部类对象
//		Outer.Inner inner = outer.new Inner();
	
		//方式2
	    Outer.Inner inner2  = new Outer().new Inner();
	    inner2.sayHello("王五");

执行结果

匿名内部类

public class Outer1 {
	private String name;

	public Outer1(String name) {
		this.name = name;
	}

	public void test() {
		System.out.println("这是我的test方法");
		Runnable run = new Runnable() {

			//Runnable是一个接口 接口是无法进行实例化对象的
			//{}内为实现Runnable接口重写其内部方法的过程是一个匿名类的过程
			//向上赋值的方式类进行声明run对象
			@Override
			public void run() {
				System.out.println("这个是run方法"+name);
			}
		};
		new Thread(run).start();
	}

}

匿名类和Inner Class一样，可以访问Outer Class的private字段和方法。之所以我们要定义匿名类，是因为在这里我们通常不关心这个类的定义，并且该类仅在定义的位置一次性使用，比直接定义Inner Class可以少写很多代码。

注意:观察Java编译器编译后的.class文件可以发现，Outer类被编译为Outer.class，而匿名类被编译为Outer$1.class

 静态内部类

//静态内部类
//静态内部类不依赖于外部类对象,不能去使用Outer2.this访问成员变量或者方法
//其余规则和静态方法相同
//静态内部类内可以定义静态的成员变量,成员方法,代码块
public class Outer2 {
	private static String nameString;
	private int age;
	static {
		System.out.println("这个是Outer2的静态代码块");
	}
	public static void test() {
		System.out.println("这个是Outer2test方法");
	}

	 static class Inner2 {
		static {
			System.out.println("这个是Inner2的静态代码块");
		}
		private static String nameString;
		private static String schoolString = "猿究院";

		public static void todo() {
			System.out.println("这个是我的普通的方法");
			System.out.println(nameString);
			test();
		}
	}

}

//内部类使用原因
//1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。
//2. 对于同一个包中的其他类来说，内部类能够隐藏起来。
//3.匿名内部类可以很方便的定义回调。
//4.使用内部类可以非常方便的编写事件驱动程序
public class Demo03 {
	public static void main(String[] args) {
		//静态内部类创建对象不依赖于外部类对象
		Outer2.Inner2 inner = new Outer2.Inner2();
	    inner.todo();
	    
	    //推荐使用类名.静态方法名进行静态方法的调用;
	    Outer2.Inner2.todo();
	}

}

 小结

●Java的内部类可分为：Inner Class（内部类）、Anonymous Class（匿名类）和 Static Nested Class（静态内部类）三种。
●Inner Class 和 Anonymous Class本质上是相同的，都必须依附于Outer Class的实例，即隐含地持有Outer.this实例，并拥有Outer Class的private访问权限。
●Static Nested Class 是独立类，但拥有 Outer Class 的private访问权限。