JAVA中的内部类

类名作为形参和返回值
方法的形参是类名，其实需要的是该类的对象
方法的返回值是类名，其实返回的是该类的对象
抽象名作为形参和返回值
方法的形参是抽象类名，其实需要的是该类的子类对象
方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
接口名作为形参和返回值
方法的形参是接口名，其实需要的是该接口的实现类对象
方法的返回值是接口名，其实返回的是该接口的实现类对象

内部类：
内部类：就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
内部类的定义格式：
public class 类名{
修饰符 class 类名{
}
}

public class Outer{
public class Inner{
}
}
内部类的访问特点：
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

按照内部类在类定义的位置不同，可以分为如下两种形式
在类的成员位置：成员内部类
在类的局部位置：局部成员类
成员内部类，外部如何创建对象使用呢？
格式：外部类名.内部类名 对象名=外部类对象.内部类对象
范例：Outer.Inner oi=new Outer().new Inner();
局部内部类：
局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量
匿名内部类：
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式：
new 类名或者接口名（）{
重写方法；
}；
范例：
new Inter(){
public void show(){
}
}
本质：是一个继承了该类或者实现了该接口的子类匿名对象

Math类概述：
Math包含执行基本数字运算的方法
没有构造方法，如何使用类中的成员呢？
看类的成员是否都是静态的，如果是，通过类名就可以直接调用
Math类的常用方法：

public class MathDemo {
public static void main(String[] args) {
System.out.println(Math.abs(88));
System.out.println(Math.abs(-88));//绝对值
System.out.println(Math.ceil(5.6));
System.out.println(Math.ceil(5.2));//向上取整
System.out.println(Math.floor(5.6));
System.out.println(Math.floor(5.2));//向下取整
System.out.println(Math.round(5.6));
System.out.println(Math.round(5.2));//四舍五入
System.out.println(Math.max(3,4));
System.out.println(Math.max(5,2));//最大值
System.out.println(Math.min(3,4));
System.out.println(Math.min(5,2));//最小值
System.out.println(Math.pow(2,4));
System.out.println(Math.pow(5,2));//2的四次方，5的二次方
//System.out.println(Math.random());//[0.0，1.0)，返回值为double的正值
System.out.println((int)(Math.random()*100)+1);//[1,100]
}
}
System类概述
public class SystemDemo {
public static void main(String[] args) {
//System.out.println(“开始”);
//System.exit(0);
//System.out.println(“结束”);
// System.out.println(System.currentTimeMillis());
//System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+“年”);
long start=System.currentTimeMillis();
for (int i = 0; i <10000 ; i++) {
System.out.println(i);
}
long end=System.currentTimeMillis();
System.out.println(“共耗时：”+(end-start)+“毫秒”);
}
}
Object类的概述
Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
构造方法：public Object()
回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为他们的顶级父类只有无参构造方法

冒泡排序：
如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与
public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
System.out.println(“排序前：” + arrayToString(arr));
/for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println(“第一次排序：” + arrayToString(arr));
for (int i = 0; i < arr.length - 1 - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println(“第二次排序：” + arrayToString(arr));
for (int i = 0; i < arr.length - 1 - 2; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println(“第三次排序：” + arrayToString(arr));
for (int i = 0; i < arr.length - 1 - 3; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println(“第四次排序：” + arrayToString(arr));
for (int i = 0; i < arr.length - 1 - 4; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}/
for (int x = 0; x < arr.length; x++) {
for (int i = 0; i < arr.length - 1 - x; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}

    }
    System.out.println("排序后：" + arrayToString(arr));
}
public static String arrayToString(int[] arr){
    StringBuilder sb=new StringBuilder();
    sb.append("[");
    for (int i = 0; i < arr.length; i++) {
        if(i==arr.length-1){
            sb.append(arr[i]);
        }
        else{
            sb.append(arr[i]+", ");
        }
    }
    sb.append("]");
    String s=sb.toString();
    return s;
}

}
Arrays类的概述和常用方法：

工具类的设计思想：
构造方法用private修饰
成员用public static 修饰