java的形参，返回值，修饰符，内部类的详解

一 形式参数问题
数据类型 ：四类八种，
整数类型：byte,short ,int ,long 
浮点类型：float, double
字符类型：char
布尔类型：boolean


形式参数：
基本类型：要的是该基本类型的数据值。
引用类型：要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)
B:类   要的是该类或者其子类的对象。(地址值)
C:抽象类 要的是该抽象类的子类对象。(地址值)
D:接口 要的是该接口的实现类对象。(地址值)
二：返回值问题
返回值：
数据类型 ：四类八种，
整数类型：byte,short ,int ,long 
浮点类型：float, double
字符类型：char
布尔类型：boolean
引用类型：类，接口，数组


返回值之基本类型：
基本类型：返回的是该基本类型的数据值。
案例：创建一个加法的方法，返回值就是基本类型的具体的指
public class RetrunDemo {
public static void main(String[] args) {
//调用这个家法
System.out.println(add(1, 2));
}

//创建一个方法，可以做两个数的加法，并返回两个数的和
public static int add(int a,int b){
return a+b;
}

返回值之引用类型：
返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
返回值是接口名：要的是该接口的实现类对象。(地址值)


三：权限修饰符（代码进行测试）
  权限修饰符：在哪种情况下可以被访问到。
    本类     同一个包下的类        不同包下的子类            不同包下的无关类
private yes     no         no no
默认(什么都不写) yes    yes                 no no
protected yes             yes                   no no
public        yes                 yes                yes   yes


四：常见的内容修饰
1:常见的修饰

类：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() {}


2:哪些东西可以修饰哪些东西
        类 成员变量 构造方法 成员方法
private     Y             Y               Y
默认 Y       Y             Y                     Y
protected     Y               Y                            Y
public Y     Y       Y                 Y
static       Y                  Y
final Y       Y                                             Y
abstrac  Y             Y


注意：
四种权限修饰符，只能有一种存在。


class Demo {}


常见的组合：
类：
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类，b类就是内部类


访问特点：（代码验证只要编译通过说明就是没有问题的）
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。


内部类分类：
成员位置：成员内部类
局部位置：局部内部类
成员内部类：
外界如何创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象;


class Outer{
//创建一个外部类的私有化的成员变量
private int num = 30;

//创建一个show方法，show方法内部有一个局部内部类
public void show(){
//设置一个show方法的局部变量
final int num2 = 40;//num2被加上final之后，num2变成了常量，其实本质上他就是40
//创建局部内部类
class Inner{
//存在一个function方法
public void function(){
System.out.println(num2);
//System.out.println(40);
//编译：java -- class
//反编译：class -- java
/**
* 问题：局部内部类的成员方法访问局部变量的时候，局部变量为什么必须加上final就不报错了呢？？
* 我们的show方法在调用的时候存在于栈内存，当show方法调用完毕之后，他的局部变量num2会随着show
* 方法调用完毕二消失，但是现在存在一个问题，show方法中的局部对象不会立即从栈内存中直接释放掉，他还保留着num2,
* 此时就发生了矛盾，局部对象想使用这个num2这个变量，但是他又急着从栈内存中消失。。。，所以我们需要给num2加上final关键字
* 是他变为常量
*/
}
}

//需求：在show方法中调用局部内部类的function方法
//创建局部内部类对象
Inner i = new Inner();
i.function();
}

}




public class InnerClassDemo {
public static void main(String[] args) {
//创建外部类对象
Outer o = new Outer();
o.show();
}


}


成员内部类的修饰：
    A:private 为了我们访问数据的安全性
B:static  为了我们访问数据的方便性




局部内部类：
        A:可以直接访问外部类的成员，包括私有
B:在成员方法中创建局部内部类的对象，调用局部内部类的功能
为什么：局部内部类访问局部变量必须加final修饰呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
匿名内部类
没有名字的局部内部类,就是内部类的简化写法


前提：
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。


格式：
new 类名或者接口名() {
重写方法;
};


本质：

是一个继承了类或者实现了接口的子类匿名对象。

实例：

interface Inter { void show(); }
class Outer{
public static Inter method() {
return new Inter(){
public void show(){
System.out.println("helloworld");
}
};
}
}
class InnerClassTest {
public static void main(String[] args) {


 Outer.method().show();
 }
}