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

绝地灬酷狼 2022-06-17 05:12 147阅读 0赞

**一 形式参数问题**  
数据类型 ：四类八种，  
整数类型：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();  
 \}  
\}