Java 創建隱藏文件

这篇专栏的笔记是面向对象三大特性之一：封装

封装：将类的某些信息隐藏起来，不允许外部直接访问。

作用：1.只能通过规定的方法访问数据。
      2.隐藏类的实现细节。

1、访问控制符

一般通过修改访问修饰符来控制访问范围，访问修饰符包括：public、protected、default、private。

图1 访问控制符

2、访问私有变量

1.变量age被private修饰，成为私有变量。
2.访问私有变量需要借助set()方法和get()方法，不可以通过对象直接访问。

//Student.java
public class Student {	//类的定义

	private int age;    //私有变量

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}
}


//Init.java
public class Init {		//访问私有变量
	public static void main(String[] args) {
		Student s = new Student();
		//成员变量age被private修饰，不可通过对象直接访问
		s.age = 18; //会报错
		//可通过setter和getter方法访问被private修饰的成员变量
		s.setAge(18);
		System.out.println("Age:" + s.getAge());
	}
}

3、this关键字

其中，我们发现set()方法中出现了this关键字，它代表当前对象，如图3。等号左边的this.age是成员变量，等号右边的age是形参。

public void setAge(int age) {
	this.age = age;		//this关键字
}

也可以通过修改形参加以区分。其中，age是成员变量，myAge是形参，这样就不需要用到this关键字。

public void setAge(int myAge) {
	age = myAge;
}

4、内部类

内部类：定义在类内部的类。与内部类相对应的概念叫外部类，即外部类中定义了内部类。

public class Outer {    //外部类
	public class Inner{     //内部类
		public void myPrint(){
			System.out.println("内部类中的方法");
		}
	}

	public static void main(String[] args) {
		//创建外部类对象
		Outer outer = new Outer();
		//创建内部类对象
		Inner inner = outer.new Inner();
		//调用内部类中的方法
		inner.myPrint();
	}
}

——为什么要用内部类？
1.可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
2.内部类中的方法可以直接访问外部类的所有数据。

内部类分为四种：
成员内部类、静态内部类、方法内部类、匿名内部类。

5、成员内部类

1.内部类可直接访问外部类的变量，即使该变量是私有的。

public class Outer {    //外部类
	private int a = 1;  //外部类私有变量
	public class Inner{     //内部类
		public void show(){
			//可直接访问外部类私有变量
			System.out.println(a);
		}
	}
}

2.外部类和内部类出现同名变量时，内部类优先访问内部类变量。若要访问外部类变量，格式为"外部类.this.变量名"。

public class Outer {    //外部类
	//外部类和内部类出现同名变量的情况
	private int a = 1;
	public class Inner{     //内部类
		int a = 2;
		public void show(){
			//访问内部类变量
			System.out.println(a);
			//访问外部类变量
			System.out.println(Outer.this.a);
		}
	}
}

3.调用内部类的不同方式。

public static void main(String[] args) {
	//第一种方法
	Outer.Inner inner1 = new Outer().new Inner();
	inner1.show();
	//第二种方法
	Outer outer2 = new Outer();
	Inner inner2 = outer2.new Inner();
	inner2.show();
}

6、静态内部类

1.静态内部类可以直接访问外部静态成员，但不能直接访问外部非静态成员。
2.静态内部类访问外部非静态成员需要通过外部类对象访问。

public class Outer {    //外部类
	int a = 5;
	static int b = 7;
	public static class Inner {     //内部类，静态
		public void show() {
			//静态内部类不能直接访问外部非静态成员
			System.out.println(a);  //会报错
			//若要访问，需要通过外部类对象访问
			System.out.println(new Outer().a);
			//静态内部类不能直接访问外部静态成员
			System.out.println(b);
		}
	}
}

3.外部类和内部类出现同名变量时，内部类中的方法访问这两个变量方式不同。
4.可直接创建静态内部类对象。

public class Outer {    //外部类
	//外部类和内部类出现同名变量的情况
	static int a = 5;
	public static class Inner {     //内部类，静态
		int a = 8;
		public void show() {
			//访问内部类变量
			System.out.println(a);
			//访问外部类变量
			System.out.println(Outer.a);
		}
	}

	public static void main(String[] args) {
		//直接创建内部类对象，无需创建外部类对象
		Inner inner = new Inner();
		inner.show();
	}
}

7、方法内部类

1.外部类中有方法，方法中有类，这个类叫做方法内部类。
2.方法内部类只能在方法中使用，不能使用访问控制符和static。

public class Outer {    //外部类
    public void show() {	//方法内部类
        int a = 5;
        //****************************************************//
        //外部类中有方法，方法中有类，此类称为方法内部类
        //这个内部类只能在该方法中使用，不能使用访问控制符和static
        class Inner {     //内部类，静态
            int b = 7;
            public void show(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        //****************************************************//
        //下面两行代码在外部类方法之内，内部类之外
        //只有在show()方法内，才能创建内部类对象
        Inner inner = new Inner();
        inner.show();
    }

    public static void main(String[] args) {
        //直接创建内部类对象，无需创建外部类对象
        Outer outer = new Outer();
        outer.show();
    }
}

（匿名内部类需要用到继承、接口等操作，该类会在后续记录）