Java进阶知识之零基础（四）

1.内部类的概述：

​         就是在一个类中定义一个类。

public class Outer{
  public class Innter{
  }
}

public class TestInner {
    public static void main(String[] args) {
        
        Outer.Inner i = new Outer().new Inner();
        System.out.println(i.num);
        i.show();
    }
}
​
class Outer {
    int a = 10;
    private int b = 20;
    class Inner {
        int num = 10;
​
        public void show() {
            System.out.println("内部类的show方法");
            //内部类访问外部类成员，可以直接访问，包括私有
            System.out.println(a);
            System.out.println(b);
        }
    }
}

（1）成员内部类：在类的成员位置：

        private：私有成员内部类访问：在自己所在的外部类中创建对象访问。

public class TestInner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();// 内部类show方法
    }
}
​
class Outer{
    private class Inner{
        public void show(){
            System.out.println("内部类show方法");
        }
    }
​
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

        static： 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

​                     静态成员内部类中的静态方法：外部类名.内部类名.方法名();

public class TestInner {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer.Inner();
        oi.show();// 我是内部类show方法
​
        Outer.Inner.method();// 我是内部类静态方法method
    }
}
​
class Outer{
    static class Inner{
        public void show(){
            System.out.println("我是内部类show方法");
        }
​
        public static void method(){
            System.out.println("我是内部类静态方法method");
        }
    }
}

（2）局部内部类：在类的局部位置：

        局部内部类是在方法中定义的类，所以外界是无法直接使用的，需要在方法内部创建对象并使用。

public class TestInner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();// 我是局部内部类的show方法 10 20
    }
}
​
class Outer {
    int a = 10;
​
    public void method() {
        int b = 20;
​
        class Inner {
            public void show() {
                System.out.println("我是局部内部类的show方法");
                System.out.println(a);
                System.out.println(b);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}

2.匿名内部类：

​         概述：本质上是一个特殊的局部内部类。

​         前提：需要存在一个接口或类。

new 类名或者接口名(){
  重写方法；
}；

public class TestInner {
    public static void main(String[] args) {
        InterImpl i =new InterImpl();
        i.show();// 重写的show方法
​
        
        new Inter(){
            public void show(){
                System.out.println("我是匿名内部类的show方法");
            }
        }.show();// 我是匿名内部类的show方法
        
        Inter2 inter = new Inter2(){
            public void show1(){
                System.out.println("show1");
            }
            public void show2(){
                System.out.println("show2");
            }
        };
        inter.show1();
        inter.show2();
    }
}
​
interface Inter{
    void show();
}
​
interface Inter2{
    void show1();
    void show2();
}
class InterImpl implements Inter{
    public void show(){
        System.out.println("重写的show方法");
    }
}

3.匿名内部类在开发中的使用场景：

public class TestSwimming {
    public static void main(String[] args) {
​
        goSwimming(new Swimming(){
            public void swim(){
                System.out.println("游泳");
            }
        });
    }
    public static void goSwimming(Swimming swimming){
        swimming.swim();
    }
}
​
interface Swimming{
    void swim();
}

1.Lambda表达式的标准格式：

(形式参数)->{代码块}

2.Lambda表达式的使用前提：

（1）有一个接口；

（2）接口中有且仅有一个抽象方法。

3.Lambda表达式练习：

练习1：

public class TestLambda {
    public static void main(String[] args) {
        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类的show方法");
            }
        });
​
​
        //Lambda：
        useShowHandler(()->{
            System.out.println("我是Lambda表达式中show方法");
        });
    }
​
    public static void useShowHandler(ShowHandler showHandler){
        showHandler.show();
    }
}
​
interface ShowHandler{
    void show();
}

练习2：带参无返回值

public class TestLambda {
    public static void main(String[] args) {
        useStringHandler((String msg)->{
            System.out.println(msg);
        });
    }
​
    public static void useStringHandler(StringHandler stringHandler){
        stringHandler.printMessage("lijiashun");
    }
}
​
interface StringHandler{
    void printMessage(String s);
}

练习3：无参有返回值

import java.util.Random;
​
public class TestLambda {
    public static void main(String[] args) {
        useRandomNumberHandler(()->{
            Random r = new Random();
            int num = r.nextInt(10) + 1;
            return num;
        });
    }
​
    public static void useRandomNumberHandler(RandomNumberHandler randomNumberHandler){
        int result = randomNumberHandler.getNumber();
        System.out.println(result);
    }
}
​
interface RandomNumberHandler{
    int getNumber();
}

练习4：带参有返回值

public class TestLambda {
    public static void main(String[] args) {
        useCalculator((int a, int b) -> {
            return a + b;
        });
    }
​
    public static void useCalculator(Calculator calculator) {
        int result = calculator.clac(10, 20);
        System.out.println(result);
    }
}
​
interface Calculator {
    int clac(int a, int b);
}

4.省略形式：

public class TestLambda {
    public static void main(String[] args) {
        useCalculator((a, b) ->
                a + b
        );
    }
​
    public static void useCalculator(Calculator calculator) {
        int result = calculator.clac(10, 20);
        System.out.println(result);
    }
}
​
interface Calculator {
    int clac(int a, int b);
}

5.Lambda表达式和匿名内部类的区别：

（1）所需类型不同：

​         匿名内部类：可以是接口，也可以是抽象类，还可以是具体类。

​         Lambda表达式：只能是接口。

（2）使用限制不同：

​         如果接口中有且只有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类。

​         如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式。

（3）实现原理不同：

​         匿名内部类：编译之后，产生一个单独的.class字节码文件.

​         Lambda表达式：编译之后，没有一个单独的.class字节码文件.对应的字节码文件在运行的时候动态生成。

1.Math：

public class JavaAdvanced03_Math {
    
    public static void main(String[] args) {
        int abs = Math.abs(-10);
        System.out.println(abs);//10

        double ceil = Math.ceil(10.7);
        System.out.println(ceil);//11.0

        double floor = Math.floor(10.7);
        System.out.println(floor);//10.0

        long round = Math.round(10.1);
        System.out.println(round);//10

        int max = Math.max(10, 11);
        System.out.println(max);//11

        int min = Math.min(10, 11);
        System.out.println(min);//10

        double pow = Math.pow(2, 3);
        System.out.println(pow);//8.0

        double random = Math.random();
        System.out.println(random);
    }
}

2.system：

public class JavaAdvanced03_System {
    
    public static void main(String[] args) {
//        System.out.println(111);
//        System.exit(0);
//        System.out.println(222);//不显示222
​
        long l = System.currentTimeMillis();
        System.out.println(l);
​
        int[] array1 = {1,2,3,4,5};
        int[] array2 = new int[10];
        System.arraycopy(array1,0,array2,3,5);
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);//0 0 0 1 2 3 4 5 0 0
        }
    }
}

3.Object：

（1）所有类都直接或者间接继承object类；

（2）直接打印一个对象就是打印这个对象的toString方法的返回值；

（3）Object类的toString方法得到的是对象的地址值；

（4）我们一般会对toString方法进行重写。

public class JavaAdvanced03_Student {
    private String name;
    private int age;
​
    public JavaAdvanced03_Student() {
    }
​
    public JavaAdvanced03_Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
​
        JavaAdvanced03_Student that = (JavaAdvanced03_Student) o;
​
        if (age != that.age) return false;
        return name != null ? name.equals(that.name) : that.name == null;
    }
}

public class JavaAdvanced03_equals {
    public static void main(String[] args) {
        JavaAdvanced03_Student stu1 = new JavaAdvanced03_Student("lijiashun",20);
        JavaAdvanced03_Student stu2 = new JavaAdvanced03_Student("lijiashun",20);
​
        System.out.println(stu1 == stu2);//false
        //Object类中的equals方法，底层使用==比较地址值
        System.out.println(stu1.equals(stu2));//true
    }
}

4.BigDecimal:

import java.math.BigDecimal;
​
public class JavaAdvanced03_BigDecimal {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal(10.0);
        BigDecimal bd2 = new BigDecimal("0.3");
        System.out.println(bd1);
        System.out.println(bd2);
​
        BigDecimal bd3 = new BigDecimal("0.1");
        BigDecimal bd4 = new BigDecimal("0.2");
​
        BigDecimal add = bd3.add(bd4);
        System.out.println(add);// 0.3
​
        BigDecimal subtract = bd3.subtract(bd4);
        System.out.println(subtract);// -0.1
​
        BigDecimal multiply = bd3.multiply(bd4);
        System.out.println(multiply);// 0.02
​
        BigDecimal divide = bd3.divide(bd4);
        System.out.println(divide);// 0.5
    }
}