package-内部类-四种权限修饰符
包的定义及注意事项
-
定义包的格式
- 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!");
}
}
}
}
