面向对象三大特性-封装

1、定义：

将类的某些属性隐藏在类内部，不允许外部程序直接访问，而是通过类内部的方法来实现对隐藏信息的访问和操作；

2、访问修饰符：

3、this关键字

this表示当前对象 

this.属性 操作当前对象的属性

this.方法 调用当前对象的方法

4、内部类

定义：内部类（Inner Class）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

作用：1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

   2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

   3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便       

分类：

1)成员内部类：内部类中最常见的就是成员内部类，也即是普通内部类

//外部类HelloWorld
public class HelloWorld{
    //外部类的私有属性name
    private String name = "imooc";
    //外部类的成员属性
    int age = 20;
	//成员内部类Inner
	public class Inner {
		String name = "爱慕课";
        //内部类中的方法
		public void show() { 
			System.out.println("外部类中的name：" + HelloWorld.this.name );
			System.out.println("内部类中的name：" + name );
			System.out.println("外部类中的age：" + age);
		}
	}
	//测试成员内部类
	public static void main(String[] args) {
        //创建外部类的对象
		HelloWorld o = new HelloWorld (); 
        //创建内部类的对象
		Inner inn =  o.new Inner();
        //调用内部类对象的show方法
		inn.show();
	}
}

成员内部类使用方法：

① Inner类定义在Outer类的内部，相当于Outer类的一个成员变量。Inner类可以使用任意访问修饰符

②Inner类中的方法可以任意访问Outer类中的属性、方法，而不受访问修饰符限制（通过Outer.this.外部类属性，或者 Outer.this.外部类方法 访问）

③内部类需要通过外部类的对象来创建内部类对象，不能直接创建对象，即：内部类 对象名 = 外部类对象.new 内部类()

④编译HelloWorld后会生成两个.class文件HelloWorld.class和HelloWorld$Inner.class

⑤外部内不能直接访问内部类的属性和方法，只能通过创建内部类对象，通过对象访问其属性及方法

2)静态内部类

指的是使用static修饰的内部类

①静态内部类不能直接访问外部类的非静态成员，但可以通过 new外部类().成员 的方式访问

②如果外部类的静态成员与内部类的成员名相同，通过外部类.静态成员访问外部静态成员；如果成员名不同，直接通过成员名访问

③创建静态内部类对象不需要外部类对象，可以直接通过 内部类 对象 = new 内部类() 创建

3)方法内部类

方法内部类就是内部类定义在外部类的方法中，不能使用访问修饰符和static修饰符，只能方法内部使用

4)匿名内部类（多用在Android）

匿名内部类就是没有名字的局部内部类，不使用关键字class，extends，implements，且没有构造方法

匿名内部类的适用场景：

a、只用到类的一个实例

b、类在定义后马上用到

c、类非常小

d、并不会使代码更容易理解

适用匿名内部类的几个原则：

a、匿名内部类不能有构造方法

b、匿名内部类不能使用static修饰类、方法、属性

c、匿名内部类没有访问修饰符

d、只能创建一个实例

e、一个匿名内部类一定是在new方法后面，隐含实现一个接口或一个实现类

f、匿名内部类属于局部内部类

匿名内部类的适用：

package anonymousinner;
 public interface Qinshou {
     public void workInNight();
 }

 package anonymousinner;
    public abstract class Doctor implements Qinshou {
    //多态，情况不定
            public void workInDay(){
                 System.out.println("白天传授理论知识");
             }
         }

 package anonymousinner;
         public class Doctor1 extends Doctor {
             public void workInNight(){
                System.out.println("晚上教弹琴");
             }
 }
 package anonymousinner;
         public class Doctor2  extends Doctor{
             public void workInNight(){
                 System.out.println("晚上学习");
             }
 }

    package anonymousinner;
          public class Test {
              public static void main(String[] args) {
                 Doctor1 d1 = new Doctor1();
                 d1.workInDay();
                 d1.workInNight();
                 Doctor2 d2 = new Doctor2();
                 d2.workInDay();
                 d2.workInNight();
                //语法格式
                 //1、new 抽象类或者接口
                 //2、后加大括号
                 //3、实现未实现方法
                 Doctor d3 = new Doctor(){
                     //匿名内部类
                     public void workInNight() {
                                 System.out.println("睡觉");
                     }
                 };
                 d3.workInDay();
                 d3.workInNight();
            }
      }