java-形参 返回值 成员（匿名）内部类

引言
返回值问题、返回值问题、权限修饰符以及内部类的相关概念，其中，内部类需要重点理解。
形式参数问题
数据类型：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类,接口,数组
形式参数：
基本类型：要的是该基本类型的数据值。
引用类型：要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)
B:类 要的是该类或者其子类的对象。(地址值)
C:抽象类 要的是该抽象类的子类对象。(地址值)
D:接口 要的是该接口的实现类对象。(地址值)
举其中一个例子：

//数组 要的是该数据类型数组的对象。(地址值)
public class ArgsStu01 {
    public static void main(String[] args) {
        int[] arr={1,5,3,2,6};
        printArr(arr);
    }
    public static void printArr(int[] arr){
        for(int i=0;iout.print(arr[i]+" ");
        }
    }
}

再写一个抽象类的相关例子：

public class ArgsStu02 {
    public static void main(String[] args) {
        PersonStu ps=new PersonStu();
        Person s=new Student();
        ps.function(s);
    }
}
abstract class Person{
    public abstract void eat();
}
class Student extends Person{
    @Override
    public void eat() {
        System.out.println("大多数学生喜欢吃米饭");
    }
} 
class PersonStu{
    public void function(Person s){
        s.eat();
    }
}

返回值问题
返回值：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类，接口，数组
返回值之基本类型：
基本类型：返回的是该基本类型的数据值。
返回值之引用类型：
返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
返回值是接口名：要的是该接口的实现类对象。(地址值)
在这里，举一个返回值类型是接口名的简例：

interface Inter{
    public abstract void jumpCat();
}
class Cat implements Inter{
    @Override
    public void jumpCat() {
        System.out.println("猫会跳高");
    }
}
class InterStu{
    public Inter method(){
        Inter c=new Cat();
        return c;

    }
}
public class ArgsStu03 {
    public static void main(String[] args) {
        InterStu is=new InterStu();
        Inter c2=is.method();
        c2.jumpCat();
    }
}

权限修饰符
权限修饰符：在哪种情况下可以被访问到。

下面举一个在同一个类中的权限修饰符的访问特点：

public class Fu {
    public static void main(String[] args) {
        //调用下面的四个方法
        Fu f = new Fu();
        f.show();
        f.show2();
        f.show3();
        f.show4();
    }
    //使用public修饰的show()
    public void show(){
        System.out.println("public");
    }
    //使用private修饰的show2()
    private void show2(){
        System.out.println("private");
    }
    //默认修饰符修饰的show3()方法
    void show3(){
        System.out.println("默认修饰符");
    }
    //使用protected修饰的show4()
    protected void show4(){
        System.out.println("protected");
    }
}

编译运行结果为：
public
private
默认修饰符
protected
常见的修饰：
类：public
public class HelloWorld {}
成员变量：private
private String name;
private int age;
构造方法：public
public Student() {}
public Student(String name,int age) {}
成员方法：public
public void show() {}
public void eat() {}
有关权限修饰符还有一个知识点需要注意，如下图：

注意：
四种权限修饰符，只能有一种存在。
常见的组合：
类：
public class HelloWorld {}
public final class HelloWorld {}
public abstract class HelloWorld {}
成员变量：
private String name;
public final int X = 10;
public static int y = 20;
public static final int X = 30;
成员方法：
public void show(){}
public abstract void show();
public final void show(){}
public static void show() {}
public static final void show() {}
内部类
有关内部类的相关知识点是一个比较难理解的地方，特别是对于我这个初学者，因此，有关的概念必须清晰明了，相关代码也必须多多练习。
内部类：
把类A定义在类B的内部，类A就被称为内部类。
访问特点：
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。
例如下面代码所示：

//外部类
class Outer{
    private int num=10;
    //内部类
    class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    //外部类的一个方法
    public void method(){
        Inner i=new Inner();
        i.show();
    }
}
public class InnerStu01 {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

编译yun运行结果为：
10
内部类分类：
成员位置：成员内部类
局部位置：局部内部类
成员内部类：
外界如何创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
有关成员内部类创建对象举一个简单的例子：

//成员内部类
class Outer2{
    class Inner{
        public void show(){
            System.out.println("这是一个成员内部类");
        }
    }
}
public class InnerStu02 {
    public static void main(String[] args) {
        //外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer2.Inner oi=new Outer2().new Inner();
        oi.show();  
    }
}

成员内部类的修饰：
A:private 为了我们访问数据的安全性
B:static 为了我们访问数据的方便性
局部内部类：
A:可以直接访问外部类的成员，包括私有
B:在成员方法中创建局部内部类的对象，调用局部内部类的功能
局部内部类访问局部变量必须加final修饰！！！
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
下面用一个例子说明：

//  局部内部类
class Outer3{
    private int num=20;
    public void show(){
         final int num=30;
         //内部类
         class Inner3{
             public void method(){
                 System.out.println(num);
             }
         }
         Inner3 i=new Inner3();
         i.method();
    }
}
public class InnerStu03 {
    public static void main(String[] args) {
        Outer3 oi=new Outer3();
        oi.show();
    }
}

编译运行后输出：
30
匿名内部类
没有名字的局部内部类,就是内部类的简化写法
前提：
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式：
new 类名或者接口名() {
重写方法;
};
本质：
是一个继承了类或者实现了接口的子类匿名对象。
举一个简单的例子：

//匿名内部类
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗都喜欢啃骨头");
    }
}
class AnimalStu{
    public void show(Animal a){
        a.eat();
    }
}
public class InnerStu04 {
    public static void main(String[] args) {
        AnimalStu as=new AnimalStu();
        as.show(new Dog());
        as.show(new Animal(){
            public void eat() {
                System.out.println("动物也有不吃肉的");
            }
        });
    }
}

编译运行后结果为：
狗都喜欢啃骨头
动物也有不吃肉的