JavaSE-权限修饰符、内部类、匿名内部类 、packge、传参

• 一、内部类
• 二、参数传递
• 三、匿名内部类
• 四、包（packge关键字）
• • 4.1 导包（import关键字）
  • 4.2 四种权限修饰符
  • • 4.2.1、默认权限(default)
    • 4.2.2、受保护权限(protected)
    • 4.2.3、私有权限(private)
    • 4.2.4、公共权限(public)
  • 4.2 类及其所组成的常见修饰符

一、内部类

（1）定义：将一个类定义到另一个类的内部，我们称之为内部类。

在类A中定义一个类B，那么我们把A叫做外部类，把B叫做内部类。

（2）分类：

a.成员内部类：将内部类定义到外部类的成员位置（类中方法外）

b.局部内部类：将内部类定义到外部类的局部位置（类中方法中）

（3）举例

class A{
    class B { //成员内部类
    }

    public void waiShow(){
        class C{ //局部内部类
        }
    }
}

其中B是成员内部类，C是局部内部类。

（4）关于访问内部类的成员和方法

举例说明：

public class MyTest {
    public static void main(String[] args) {
        //调用内部类的方法，要创建内部类的对象
        Outer.Inner inner=new Outer().new Inner();
        inner.innnerShow();
        //内部类的特点：内部类可以直接访问外部类的成员,包括私有的成员
        //外部类想要调用内部类的成员，得创建内部类对象
    }
}

public class Outer {
    int num=10;
    private int a=20;
    //定义一个成员内部类
    class Inner{
        int aa=1;
        public void innnerShow(){
            System.out.println("内部类的show方法");
            System.out.println(num);
            System.out.println(a);
            waiShow();
            waiTest();
        }

    }
    public void waiShow(){
        System.out.println("这是外部类的方法");
    }
    private void waiTest(){
        System.out.println("外部类的私有方法");
    }
    public void test(){
        //外部类想要访问内部类的成员，得创建内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.aa);
    }
}

（5)总结：
a.内部类可以直接访问外部类的成员,包括私有的成员

b.外部类想要调用内部类的成员，得创建内部类对象

(6)在主方法中调用内部类的方法，创建内部类的对象格式为：

外部类类名.内部类类名 方法名=new 外部类类名（）.new内部类类名（）；

例如 Outer.Inner inner=new Outer().new Inner();

二、参数传递

（1）如果你以后看到一个方法的形参要一个类 类型你就传一个该类对象

举例

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.show(new Student(),20);
        System.out.println(student.num);
    }
}
class Student{
    int num=100;
    public void show(Student stu,int num){
        stu.num=num;
    }
}

（2）如果你以后看到一个方法的形参要一个 抽象类 类型，你就传一个该类的子类对象

举例

public class MyTest2 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        setMethod(dog,114);
    }
    private static void setMethod(Animal an,int num) {
        an.show(num);
    }
}
abstract class Animal{
    int num=110;
    public abstract void show(int a);
}

class Dog extends Animal{
    int num=20;
    @Override
    public void show(int num) {
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

（3）如果你以后看到一个方法的形参要一个 接口 类型 你就传一个该接口的子类对象

举例：

public class MyTest3 {
    public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个 接口 类型 你就传一个该接口的子类对象
        MyClass myClass = new MyClass();
        test(myClass,22);
    }
    private static void test(MyInterface myInterface,int b) {
        myInterface.show(b);
    }
}

interface MyInterface{
    int NUM=100;
    void show(int a);
}

class MyClass implements MyInterface{
    int b=10;
    @Override
    public void show(int a) {
        System.out.println(this.b);
        System.out.println(NUM);
        System.out.println(MyInterface.NUM);
    }
}

三、匿名内部类

（1）定义：

匿名内部类：是局部内部类的一种简写方式。匿名内部类本质上是一个对象，是谁的对象，是实现了该接口或继承了该抽象类的子类对象

（2）匿名内部类的前提条件：

要有一个接口或者抽象类（普通的类的也行）

（3）语法：

new 接口名/类名(){
要重写的方法
};

（4）举例

public class MyTest2 {
    public static void main(String[] args) {
       
        new Animal(){
            @Override
            public void eat() {
                System.out.println("吃鸡");
            }
        };

        new MyInterface(){
            @Override
            public void show() {
                System.out.println("hehhehe");
            }
        }.show();


    }
}

abstract class Animal{
    public abstract void eat();
}

interface MyInterface{
    void show();
}

四、包（packge关键字）

（1）定义：就是文件夹

（2）作用：用来解决同一个路径下不能存在同名文件的问题(分类管理)

（3）格式：

package 包名;

（4）注意事项：

A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package，默认表示无包名

4.1 导包（import关键字）

（1）定义：

不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能

（2）格式：

import 包名;

（3）packge，import，class的顺序关系

packge>import>class

四种权限修饰符摘要

4.2 四种权限修饰符

Java语言4种访问权限修饰符，但是仅有3个关键字，因为不写访问权限，在Java中被称为默认权限，或同包权限，本文中以(default)代替。下面按照权限从小到大的顺序对4种访问权限分别介绍

4.2.1、默认权限(default)

类，数据成员，构造方法，方法成员，都能够使用默认权限，即不写任何关键字。默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。

4.2.2、受保护权限(protected)

protected可以修饰数据成员，构造方法，方法成员，不能修饰类(此处指外部类，不考虑内部类)。被protected修饰的成员，能在定义它们的类中，同包的类中被调用。如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类。

4.2.3、私有权限(private)

private可以修饰数据成员，构造方法，方法成员，不能修饰类(此处指外部类，不考虑内部类)。被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用。

4.2.4、公共权限(public)

public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。

有关Java语言的修饰符，需要注意的问题有如下几个：

1.并不是每个修饰符都可以修饰类(指外部类)，只有public和default可以。

2.所有修饰符都可以修饰数据成员，方法成员，构造方法。

3.为了代码安全起见，修饰符不要尽量使用权限大的，而是适用即可。比如，数据成员，如果没有特殊需要，尽可能用private.

4.修饰符修饰的是“被访问”的权限。

4.2 类及其所组成的常见修饰符

A:修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
B:修饰类的关键字：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract

用的最多的就是：public

C:修饰成员变量的关键字：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final

用的最多的就是：private

D:修饰构造方法的关键字：
权限修饰符：private，默认的，protected，public

用的最多的就是：public

E:修饰成员方法的关键字：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

用的最多的就是：public

F:除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final