JAVA学习记录day4

今日主要内容:包,修饰符总结,内部类

所谓包,可以说就是一个文件夹。通过定义包,可以管理字节码文件,也产生了不同的访问权限。
包的定义:在源文件的第一个可执行语句中用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的学习。

推荐阅读更多精彩内容