package-内部类-四种权限修饰符

目录

• 包的定义及注意事项
• 四种权限修饰符的测试
• 类及其组成所使用的常见修饰符
• 内部类概述及访问特点
• 成员内部类的面试题
• 局部内部类访问局部变量的问题（很少出现）
• 匿名内部类
• 匿名内部类的面试题

---

返回 我的技术栈(Technology Stack)

---

包的定义及注意事项

---

• 定义包的格式

  • package 包名
  • 多级包用.分开即可

• 定义包的注意事项

  • package语句必须是程序的第一条可执行的代码

  • package语句在一个Java文件中只能有一个

  • 如果没有package，默认表示无包名

    package com.heima;
    class Demo_package {
    public static void main(String[] args) {
    System.out.println("hahaha");
    }
    }

• 如何编译运行带包的类？

  • 1、Javac编译的时候带上-d即可：javac -d . HelloWord.Java

  • 2、通过Java命令执行：Java 包名.HelloWord

    package com.heima;
    import com.baidu.Person; //在开发中都是导入具体的类
    class Demo_package {
    public static void main(String[] args) {
    Person p = new Person("张三",23);
    System.out.println(p.getName() + "------" + p.getAge());
    }
    }

    另一个.class文件
    package com.baidu;
    public class Person {
    private String name;
    private int age;

    public Person() {}
    public Person(String name,int age) {
    this.name = name;
    this.age = age;
    }

    public void setName(String name) {
    this.name = name;
    }
    public String getName() {
    return name;
    }

    public void setAge(int age) {
    this.age = age;
    }
    public int getAge() {
    return age;
    }
    }
    
    

四种权限修饰符的测试

---

四种访问修饰符的权限：
本类 同一个包下（子类和无关类） 不同包下（子类） 不同包下（无关类）
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y

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

---

类及其组成所使用的常见修饰符
1、修饰符：
（1）权限修饰符：private，默认的，protected，public
（2）状态修饰符：static，final
（3）抽象修饰符：abstract

2、类：
（1）权限修饰符：默认的，public
（2）状态修饰符：final
（3）抽象修饰符：abstract

*用的最多的是：public

3、成员变量：
（1）权限修饰符：private，默认的，protected，public
（2）状态修饰符：static，final

*用的最多的是：private

4、构造方法：
（1）权限修饰符：private，默认的，protected，public

*用的最多的是：public

5、成员方法：
（1）权限修饰符：private，默认的，protected，public
（2）状态修饰符：static，final
（3）抽象修饰符：abstract

*用的最多的是：public

6、除此以外的组合规则：
（1）成员变量：public static final
（2）成员方法：public static
public abstract
public final

内部类概述及访问特点

---

• 内部类与外部类的访问

  class InnerClass {
  public static void mian(String [] agrs) {

  //外部类名.内部类名 = 外部类对象.内部类对象
  Outer.Inner oi = new Outer().new Inner();//创建内部类对象
  oi.method();
  }

  }
  class Outer { //外部类
  private int num = 10; //内部类 可以直接访问外部类的成员，包括私有
  class Inner { //内部类
  public void method() {
  System.out.println(num);
  }
  }
  }

  输出结果：10

• 成员内部类私有使用

  class InnerClass {
  public static void main(String [] agrs) {
  Outer o = new outer();
  o.print();
  }
  }
  class Outer {
  private int num = 10;
  private class Inner { //私有化
  public void method() {
  System.out.println(num);
  }
  }

  public void print() { //内部类私有的访问方法 通过创建外部类里的访问方法
  Inner i = new Inner();
  i.method();
  }
  }

  输出结果：10

• 静态成员内部类

  class InnerClass {
  public static void mian(String [] agrs) {
  //外部类名.内部类名 对象名 = 外部类名.内部类对象
  // Outer.Inner oi = outer.new Inner(); 一般会把new提前
  Outer.Inner oi = new Outer.Inner();//创建内部类对象
  oi.method();

  Outer.Inner2.print();
  }
  }
  class Outer { //外部类
  static class Inner { //静态内部类 非静态方法
  public void method() {
  System.out.println("method");
  }
  }

  static class Inner2 { //静态内部类 静态方法
  public static void print() {
  System.out.println("print");
  }
  }
  }
  
  

成员内部类的面试题

---

要求在填空输出语句，在控制台输出30， 20， 10

class Test_Innerclass {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(outer.this.num);
}
}
}

局部内部类访问局部变量的问题（很少出现）

---

Class InnerClass {
public static void main(String [] agrs) {
Outer o = new Outer();
o.method();
}
}
//局部内部类
class Outer {
public void method() {
final int num = 10;
class Inner {
public void print() {
System.out.println(num);
}
}

Inner i = new Inner();
i.print(); //局部内部类只能在其所在的方法中访问
}
}

输出结果：10

1、局部内部类访问局部变量必须用final修饰
2、局部内部类在访问他所在方法中的局部变量必须用final修饰，为什么？
答：因为当调用这个方法时，局部变量如果没有用final修饰，他的生命周期和方法的生命周期是一样的，当方法弹栈，这个局部变量也会消失，那么如果局部内部类对象还没有马上消失想用这个局部变量，就没有了，如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也可以继续使用 但是JDK1.8取消了这个事情，所以我觉得这是个bug

匿名内部类

---

• 匿名内部类的格式和理解

  class Outer {
  class Inner implements Inter {
  public void print() {
  System.out.println("print");
  }
  }

  public void method() {
  new Inter() { //实现Inter接口
  public void print() { //重写抽象方法
  System.out.println("print");
  }
  }.print();
  }
  }

• 匿名内部类重写多个方法调用

  • 匿名内部类只针对重写一个方法时候使用
  • 如果重写多个方法，子类要重写多次

• 匿名内部类在开发中的应用

  有名字的来做

  class Test {
  public static void main(String[] args) {
  PersonDemo pd = new PersonDemo();
  pd.method(new Student());
  }
  }

  //这里写抽象类，接口都行
  abstract class Person {
  public abstract void show();
  }

  class PersonDemo {
  public void method(Person p) { //Person p = new Student();
  p.show();
  }
  }

  class Student extends Person {
  public void show() {
  System.out.println("show");
  }
  }

  用匿名来做
  class Test {
  public static void main(String[] args) {
  PersonDemo pd = new PersonDemo();
  pd.method(new Person() { //匿名内部类当作参数传递（本质把匿名内部类看做一个对象）
  public void show() {
  System.out.println("show");
  }
  });
  }
  }

  //这里写抽象类，接口都行
  abstract class Person {
  public abstract void show();
  }

  class PersonDemo {
  /Person p = new Person() { //父类引用指向子类对象
  public void show() {
  System.out.println("show");
  }
  }/
  public void method(Person p) {
  p.show();
  }
  }

  class Student extends Person {
  public void show() {
  System.out.println("show");
  }
  }
  
  

匿名内部类的面试题

---

按要求补全代码，在控制台输出HelloWord！

class Test {
public static void main(String[] args) {
Outer.method().show();
//链式编程，每次调用方法后还能继续调用方法，证明调用方法返回的是对象
//这里可以写成：Inter i = Outer.method();
i.show();
}
}

interface Inter {
void show();
}

class Outer {//补全代码
public static Inter method() {
return new Inter() {
public void show() {
System.out.println("Helloword!");
}
}
}
}