Java复习打卡day10

内部类

因为内部类在之后的代码编写过程中很少见，所以大家可以将代码敲一遍就可。

成员内部类

在Outer类里面创建一个Inner类，形成成员内部类

public class Outer {
    private int x;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }
    class Inner{
        private int x;

        public void setX(int x) {
            this.x = x;
        }

        public void say(){
            System.out.println(x);
            System.out.println(Outer.this.x);
        }
    }
}

在Main类里面调用Inner类

public class Main {
    public static void main(String[] args) {
        Outer o1 = new Outer();
        o1.setX(100);
        Outer.Inner i1 = o1.new Inner();
        //成员内部类的调用方法：
        //Outer outer = new Outer();
        //Outer.Inner i1 = outer.new Inner();
        i1.setX(200);
        i1.say();

    }
}

局部内部类

在类的方法或作用域里面创建的类。

匿名内部类

先创建一个Person接口，作为接下来创建内部类的构造器

public interface Person {
    void say();
}

用一个Main方法来创建内部类

public class Main {
    public static void main(String[] args) {
        int a = 10;
        a = 11;
        int finalA = a;
        //-------------------------------------
        new Person(){
            @Override
            public void say() {
                System.out.println("锄禾日当午，汗滴禾下土" + finalA);
            }
        }.say();
         //-------------------------------------
         //这之间就是匿名内部类的创建
    }
}

匿名内部类有几个注意点：
 1.只能访问final型的局部变量；
 2.局部内部类只能继承一个父类或者实现一个接口；
 3.不能定义构造函数；
 4.不能存在任何的static变量或者方法；
 5.匿名内部类也属于局部内部类，所以对局部内部类的限制对它也适用；
 6.它不能是抽象的。

静态内部类

静态内部类也是定义在另一个类里面的，只不过要在class的前面加上static关键字。
静态内部类不需要依赖外部类来调用的，这点有点类似静态成员属性的用法，
它的调用格式为：
	Outer.Inner i1 = new Outer.Inner();

包装类

Java秉承“万物皆对象”的观念，为8种是数据类型引入了包装类。
如下：

import java.util.Scanner;

public class Package {
    public static void main(String[] args) {
     
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一串内容");
        String text = input.next();
        int b = Integer.parseInt(text);
        //Integer提供的parseInt方法可以将字符串类型转换为int类型
        //其实，除了Integer，像Long，Float，Boolean等等
        //都有这样的将String类型的数据转换掉的方法
        int a = 1;
        System.out.println(b + a);
    }
}

可变参数

格式：返回值类型 方法名 （数据类型 ... 数组名称）{
				//可变参数是用数组存储的
				//方法体
				}

见代码

//先创建了一个Parameter类书写包含可变参数的方法
public class Parameter {
    void endlessParameter(int ... a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        System.out.println(sum);

    }
}
//在写一个Main类来实现它
public class Main {
    public static void main(String[] args) {
        Parameter p1 = new Parameter();
        p1.endlessParameter(1,2,3,5);
    }
}

递归

递归是一种之间或间接调用自己的方法。
一般不推荐使用，应为它对栈的内存要求太大了
下面给一个实例以供参考：

//求整数的阶乘  
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("你想计算的是谁的阶乘？请输入：");
        int text = input.nextInt();
        System.out.println(factorial(text));

    }
    public static int factorial(int n){
        //现在要先算n*(n-1)
        if(n == 1){
            return 1;
        }
        return n*factorial(n-1);
        //在这里调用了自己
    }
}