今日主要内容：包,修饰符总结,内部类
包
所谓包，可以说就是一个文件夹。通过定义包，可以管理字节码文件，也产生了不同的访问权限。
包的定义：在源文件的第一个可执行语句中用package 声明。一般通过域名的反写命名，如package com.gdut.java;
在定义的包之后，在控制台执行编译的语句也发生了变化，在源文件所在目录下打开控制台输入javac -d . filename.java,运行则要输入文件的全名，即要包括包名
java com.gdut.java.filename
包的产生，也产生了protected访问权限。说到访问权限，之前说private是对类的封装，因为限制了其他类访问该类内部成员的方式。但并不是说封装就是private，而只能说private是封装的一种形式，封装是相对的，在不同包下，用默认权限修饰符修饰的类就不允许其他包的类对其访问，也是一种封装形式。
视频中老师说了一个例子，生动形象hhhhh，教室的学生要访问他的钱包是不允许的，这是违法，他的钱包对学生就是封装的，当他回到家，他老婆要访问他的钱包是可以的，不然就是作死，他的钱包对他老婆就不是封装的，所以说封装是相对的。
修饰符总结
权限修饰符权限表
| 修饰符 | 本类 | 同一报下(子类与无关类) | 不同包下(子类) | 不同包下(无关类) |
|---|---|---|---|---|
| private | Y | |||
| (默认) | Y | Y | ||
| protected | Y | Y | Y | |
| public | Y | Y | Y | Y |
- 修饰符
- 权限修饰符：private,默认,protected,public
- 状态修饰符：final,static
- 抽象修饰符：abstract
- 类
- 权限修饰符：默认，public
- 状态修饰符：final
- 抽象修饰符：abstract
- 成员变量
- 权限修饰符：private,默认,protected,public
- 状态修饰符：final,static
- 构造方法
- 权限修饰符：private,默认,protected,public
- 成员方法
- 权限修饰符：private,默认,protected,public
- 状态修饰符：final,static
- 抽象修饰符：abstract
内部类
内部类，顾名思义就是定义在类内部的类。按照内部类所在的区域可以分为成员内部类和局部内部类。局部内部类就是定义在方法中的内部类。
- 成员内部类
内部类可以直接访问外部类的变量，包括私有变量，但外部类要访问内部类成员必须要创建对象
其他类创建内部类对象的方法：外部类名.内部类名 = new 外部类名() .new 内部类名();其实，只要把内部类当做外部类的成员就很好理解，new 外部类名()就是创建外部类对象，用点表示引用其成员，由于该成员是个类，所以要创建对象，new 内部类名()；于是上面的语句可以理解为外部类名.内部类名 = 外部类对象.内部类对象
class Demo_InnerClass {
public static void main(String[] args) {
//外部类名.内部类名 = 外部类对象.内部类对象
Outer.Inner io = new Outer().new Inner();
io.print();
new Outer().new Inner().print(); //匿名引用
}
}
class Outer{
private int num = 10; //外部类要访问内部类成员必须创建对象
class Inner{
public void print(){
System.out.println(num); //内部可以访问外部类成员变量,即使私有
}
}
}
- 静态内部类
class Outer{
private int num = 10;
static class Inner2{ //静态成员内部类
public void print(){
System.out.println("inner2");
}
}
在创建静态内部类对象时，不用创建外部类对象，即Inner i =Outer.new Inner2();
但由于书写习惯，编译器不允许这样的语句，要将new提前，于是变成
Inner i =new Outer.Inner2()
-
局部内部类
局部内部类与普通内部类大致相同，但有一个应特别注意的地方，内部类所在方法的局部变量必须用final修饰，即要变成常量，否则编译会报错，但在jdk1.8版本中取消了该机制，个人理解这应该是个bug。采用这种机制的原因如下：
当调用这个方法时,不用final修饰,局部变量的声明周期和该方法时一致的,当方法弹栈,这个局部变量也会消失,如果局部内部类对象没有马上消失,仍想调用该局部变量,该局部变量就没有了,用final修饰的变量会进入常量池,即使方法弹栈,常量池中的变量依然存在,仍然可以使用。
通过内存图理解这一原因
局部内部类内存图
练习代码
class Demo_InnerClass3 { //局部内部类(方法内部类)
public static void main(String[] args) {
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();
}
}
- 匿名内部类
可能很多人在匿名内部类这里会很晕。其实，只要看到它的实质就很容易理解他的用法。他的实质就是将：1、创建一个类继承或实现某接口2、重写其抽象方法3、创建对象 三个步骤融合到一个语句中进行简化。本质是一个继承了该类或者实现了该接口的子类匿名对象
从上面的本质也看出了其存在的前提：在一个方法内，有可以继承的父类或可以实现的接口。
从下面的题目理解
class Demo_NonameClass2 {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法
PersonDemo pd = new PersonDemo();
}
}
abstract class Person{
public abstract void show();
}
class PersonDemo{
public void method(Person p){ //父类引用指向子类对象
p.show();
}
}
题目中要求用Person为参数，但Person是接口，无法创造实例，只能通过创建他的子类来实现。
方法一：创建有名字的类，实现Person接口，重写里面的show()方法，再创建该类的对象作为参数传入pd中的method方法。创建了Student类实现接口，创建Student类作为method的方法。
class Demo_NonameClass2 {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法
PersonDemo pd = new PersonDemo();
//写有名字的类
pd.method(new Student()); //showname
}
}
abstract class Person{
public abstract void show();
}
class PersonDemo{
public void method(Person p){ //父类应用指向子类对象
p.show();
}
}
class Student extends Person{
public void show(){
System.out.println("showname");
}
}
方法而：通过匿名内部类，省略创建一个新的有名字的类的过程。
class Demo_NonameClass2 {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法
PersonDemo pd = new PersonDemo();
//用匿名内部类
pd.method(new Person(){ //匿名内部类当做参数传递
public void show (){
System.out.println("shownoname"); //showname
}
});
}
}
abstract class Person{
public abstract void show();
}
new Person()可以看做是创建一个匿名的Person的接口并创建对象，之后的大括号就是对接口的实现，即重写方法。就省略了创建新类的过程。
- 弊端：上面的例子看到了匿名内部的好处，但也是有弊端的，就是显然，每次使用匿名内部类要重写全部的抽象方法，当其继承的类或者接口的抽象方法很多时，直接写有名的类效率更高。而且，由于匿名内部类没有名字，不能进行向下转型，故无法调用其特有的方法。
到目前为止大致学完了JAVA有关面向对象的所有概念，接下来转向JAVA标准类库用法的学习，即API的学习。
网友评论