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;i<arr.length;i++){            System.out.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("动物也有不吃肉的");            }        });    }}

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