Java学习笔记（七）--权限修饰符 内部类

时间：2021-09-14 00:26:54

形式参数

1.数据类型：
-基本类型：byte，short，int，long，float，double，char，boolean
-引用类型：类，接口，数组
2.形式参数：
-基本类型：要的是该基本类型的数据值。
-引用类型：要的是该引用类型的对象。
–数组：要的是该数据类型数组的对象（地址值）。
–类：要的是该类或者其子类的对象（地址值）。
–抽象类：要的是该抽象类子类的对象（地址值）。
–接口：要的是该接口实现类的对象（地址值）。

返回值

1.基本类型的返回值：
返回的是该基本类型的数据值。
2.引用类型的返回值：
-返回值是类名：返回的是该类或者其子类的对象（地址值）。
-返回值是抽象类名：返回的是该抽象类的子类的对象（地址值）。
-返回值是接口：返回的是该接口的实现类的对象（地址值）。

权限修饰符

权限修饰符：在哪种情况下可以被访问到。
Java学习笔记（七）--权限修饰符 内部类

常见的内容修饰

1.常见的修饰：
-类：public

public class Student{}

-成员变量：private

private String name;
prevate int age;

-构造方法：public

public Student（）{}
public Student（String name，int age）{
this.name=name;
this.age=age;
}

-成员方法：public

public void show(){}

2.哪些修饰符可以修饰哪些东西：
Java学习笔记（七）--权限修饰符 内部类

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

内部类

1.内部类：把类A定义在类B的内部，类A 就被称为内部类。
2.访问特点：
-内部类可以直接访问外部类的成员，包括私有。
-外部类要访问内部类的成员，必须创建对象。
3.内部类分类：
-成员位置：成员内部类
-局部位置：局部内部类
4.成员内部类：
外界如何创建对象：

外部类名.内部类名 对象名 = 外部类对象.内部类对象；

5.内部类的关键词限定：
成员内部类的修饰：
-private：为了我们访问数据的安全性
-static：为了我们访问数据的方便性

举例一：Body,Heart

//private：为了我们访问数据的安全性
class Body{
private class Heart{
public void operator(){
            System.out.println("心脏是人体很重要的部分");
        }
public void method(){
if(是医生){
                Heart h=new Heart();
                h.operator();
            }
        }
    }
}

直接访问：

Body.Heart bh=new Body().new Heart();
bh.operator();

为了身体的安全，外界不能让他们直接创建对象，通过private修饰。
此时，这样来使用：

Body b=new Body();
b.method();

举例二：

//static：为了我们访问数据的方便性
        class Outer {
public static class Inner {
public void show() {
                System.out.println("show");
            }
public static void show2() {
                System.out.println("show2");
            }
        }

    }
    class InnerClassDemo{
public static void main(String[] args) {
// 限定的新静态类
//Outer.Inner oi = new Outer().new Inner();
//格式：
            Outer.Inner oi = new Outer.Inner();
            oi.show();
            oi.show2();

//Outer.Inner.show();
            Outer.Inner.show2();
        }
    }

6.局部内部类:
-可以直接访问外部类的成员，包括私有。
-在成员方法中创建局部内部类的对象，调用局部内部类的功能。

注意：为什么局部内部类访问局部变量必须加final修饰呢：因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用final修饰，这样，在堆内存里面存储的其实是一个常量值。
7.匿名内部类：
-没有名字的局部内部类，就是内部类的简化写法。
-前提：存在一个类或者接口（这里的类可以是具体类也可以是抽象类）。
-格式：

new 类名或者接口名（）{
    重写方法；
}

-本质：是一个继承了类或者实现了接口的子类匿名对象。
-匿名内部类在开发中的实际应用：
需求：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类 方式二：匿名内部类的方式）

interface Person{
public abstract void eat();
}
class man implements Person{
public void eat(){
        System.out.println("人都需要吃饭");
    }
}
class Person2{
//创建一个方法，方法的参数是一个接口类型
public void show(Person p){
        p.eat();
    }
}
class InnerClassDemo{
public static void main(String[] args){
//调用Person2中的show方法
        Person2 p2=new Person2();
        p2.show(new man());//传入接口的实现类对象

//使用匿名内部类的方式进行传参
        p2.show(new Person(){//这里的匿名内部类，实际上就是实现了Person这个接口的一个实现类对应的匿名对象
public void eat(){
                System.out.println("不同的人喜欢吃不同的东西");
            }
        });
    }
}
标签：

相关文章