【Java】封装

封装

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

实现步骤：1，修改属性可见性，设为private

		 2，创建getter/setter方法，用于属性读写

		 3，在getter/setter方法中加入属性控制语句，对属性值的合法性进行判断

●
 包
Java中的包，管理Java文件，解决同名文件冲突

定义包：package 包名

必须放第一行，包名间用" . "隔开	com.edu.nwafu.learn

java.(功能).(类)
java.lang.(类) 包含Java语言基础的类
java.util.(类) 包含Java语言中各种工具类
java.io.(类)  包含输入，输出相关功能的类
导入包：import  com.edu.nwafu.learn；

● 
访问修饰符

private 只能在本类中访问;
默认   能在本类和同包中访问;
protected 能在本类 同包和子类中访问;
public 都能访问;
● 
this关键字
代表当前对象，
this.属性 操作当前对象的属性;
this.方法 调用当前对象的方法;

● 内部类
内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
作用：提供更好的封装，把内部类隐藏在外部类之内，不允许同一包中的其他类访问该类；
	内部类方法可以直接访问外部类的所有数据，包括私有数据；
	比外部类更方便
//外部类HelloWorld
public class HelloWorld {
    
    // 内部类Inner，类Inner在类HelloWorld的内部
    public class Inner {
        
		// 内部类的方法
		public void show() {
			System.out.println("welcome to imooc!");
		}
	}
    
	public static void main(String[] args) {
        
        // 创建外部类对象
		HelloWorld hello = new HelloWorld();
        // 创建内部类对象
		Inner i = hello.new Inner();
        // 调用内部类对象的方法
		i.show();
	}
}

内部类可分为以下几种：
成员内部类，静态内部类，方法内部类，匿名内部类

● 成员内部类
1，定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
2，外部类是不能直接使用内部类的成员和方法的，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
3，如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字
	System.out.println(Outer.this.b);\
//外部类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();
	}
}

● 静态内部类
 1，静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问,
2，如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3，创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

● 方法内部类
1，内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
2，由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
//外部类
public class HelloWorld {
    
    private String name = "爱慕课";
    
    // 外部类中的show方法
    public void show() { 
		// 定义方法内部类
		class MInner {
			int score = 83;
			public int getScore() {
				return score + 10;
			}
		}
        
		// 创建方法内部类的对象
        
        MInner mi = new MInner();
        // 调用内部类的方法
		int newScore = mi.getScore();
		System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
	}
    
	// 测试方法内部类
	public static void main(String[] args) {
        
		// 创建外部类的对象
        HelloWorld mo = new HelloWorld();
        
        // 调用外部类的方法
		mo.show();
	}
}