面向对象之内部类

一.内部类

1.含义

把类B定义在类A中，类B就被称为内部类。

2.访问规则

内部类可以直接访问外部类的成员,包括私有

外部类要想访问内部类成员,必须创建对象

3.分类

(1).成员内部类

在成员位置定义的类

(2).局部内部类

在局部位置定义的类

4.成员内部类

(1).修饰符

private 为了保证数据的安全性

static 为了方便访问数据 (注意：静态内部类访问的外部类数据必须用静态修饰)

(2).访问规则

成员内部类不是静态的：

外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

成员内部类是静态的：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

(3).面试题

/*
    面试题：
        要求请填空分别输出30，20，10。

    注意：
        1:内部类和外部类没有继承关系。
        2:通过外部类名限定this对象
            Outer.this
*/
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(new Outer().num);
            System.out.println(Outer.this.num);
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }   
}

5.局部内部类

局部内部类访问局部变量必须加final修饰。

因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。

6.匿名内部类

是局部内部类的简化形式

(1).前提

存在一个类或者接口

(2).格式

new 类名或者接口名() {
                重写方法;
            }

(3).本质

匿名内部类的本质是继承类或者实现了接口的子类匿名对象

(4).开发中的使用

我们在开发的时候，会看到抽象类，或者接口作为参数。
而这个时候，我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

面试题

/*
    匿名内部类面试题：
        按照要求，补齐代码
            interface Inter { void show(); }
            class Outer { //补齐代码 }
            class OuterDemo {
                public static void main(String[] args) {
                      Outer.method().show();
                  }
            }
            要求在控制台输出”HelloWorld”
*/
interface Inter { 
    void show(); 
    //public abstract
}

class Outer { 
    //补齐代码
    public static Inter method() {
        //子类对象 -- 子类匿名对象
        return new Inter() {
            public void show() {
                System.out.println("HelloWorld");
            }
        };
    }
}

class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
        /*
            1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
            2:Outer.method().show()可以看出method()方法的返回值是一个对象。
                又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
        */
    }
}

二.形式参数和返回值问题

1.形式参数

类名：需要该类的对象

抽象类名：需要该类的子类对象

接口名：需要该接口的实现类对象

2.返回值类型

类名：返回的是该类的对象
抽象类名：返回的是该类的子类对象
接口名：返回的是该接口的实现类的对象

3.链式编程

特点 对象.方法1().方法2()…….方法n();

注: 其实在方法1()调用完毕后，应该一个对象；
方法2()调用完毕后，应该返回一个对象。
方法n()调用完毕后，可能是对象，也可以不是对象。

三.权限修饰符

1.权限修饰符

                    本类  同一个包下   不同包下的子类 不同包下的无关类
        private     Y
        默认         Y       Y
        protected   Y       Y           Y
        public      Y       Y           Y               Y

2.这四种权限修饰符在任意时刻只能出现一种。

public class Demo {}

四.常见修饰符

1.分类：

    权限修饰符：private,默认,protected,public
    状态修饰符：static,final
    抽象修饰符：abstract

2.常见的类及其组成的修饰

    类：
        默认,public,final,abstract

        常用的：public

    成员变量：
        private,默认,protected,public,static,final

        常用的：private

    构造方法：
        private,默认,protected,public

        常用的：public

    成员方法：
        private,默认,protected,public,static,final,abstract

        常用的：public

3.另外比较常见的：

public static final int X = 10;
public static void show() {}
public final void show() {}
public abstract void show();

五.包

1.含义

其实就是文件夹

2.作用：

(1).区分同名的类

(2).对类进行分类管理

按照功能分

按照模块分

3.包的定义

格式: package 包名;

多级包用.分开。

4.注意事项

package语句必须在文件中的第一条有效语句

在一个java文件中，只能有一个package

如果没有package，默认就是无包名

5.导包

(1).含义

我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。

(2).格式：

import 包名…类名;

(3).package,import,class的顺序

package > import > class