java基础内容笔记--面向对象编程（封装性）

【注意，本人小白一个，以下是个人根据教程的理解，如有疑惑，出错的地方，希望大家能够留言指出来，相互学习进步。】

封装性
封装是java的三大特性之一，其他的两个特性是继承、多态。这次学习的是面向对象的编程，什么是面向对象呢？我在网上搜索了很多问题，最后一个博客的介绍我觉得说得简单，易懂，这里就不细说了，这里给链接跳转过去：浅谈面向对象的编程思想：如何优雅地把大象装进冰箱？

话说回来，封装型，根据字面的意思可以知道是隐蔽的信息，java的封装是通过private、public、protect关键字去实现的。

成员变量的封装
之前学习的java基础内容中，我们写的代码大多数都是用public或者是默认修饰符的。实际上是违反面向对象思想的
在面向对象实现中，是尽量让数据私有，隐蔽起来，既然是私有的，隐蔽的，访问这些变量就需要通过方法去访问。

演示例子：

class Human {
	// 成员属性都是私有的
	private String name;
	private String sex;
	private int age;
	private String addr;

	// public 的设置和访问方法
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	// 省略其他变量的 get 和 set 方法
	public void work() {
		System.out.println("我在工作");
	}

	public void eat() {
		System.out.println("我在吃饭");
	}
}

public class HumanDemo {
	public static void main(String[] args) {
		Human zhangsan = new Human();
		// zhangsan.name="张三"; 这个语句是错误的
		// 设置成员变量的值
		zhangsan.setName("张三");
		zhangsan.setAge(25);
		zhangsan.setSex("男");
		zhangsan.setAddr("中国北京");
		System.out.println("张三的个人信息如下：");
		// 打印出对象的信息，用 get 方法获得属性值
		System.out.println("姓名：" + zhangsan.getName());
		System.out.println("性别：" + zhangsan.getSex());
		System.out.println("年龄：" + zhangsan.getAge());
		System.out.println("地址：" + zhangsan.getAddr());
	}
}

运行结果：

张三的个人信息如下：
姓名：张三
性别：男
年龄：25
地址：中国北京

        在类Human中，成员变量就是私有的，如果直接调用里面的成员变量是不能直接的访问的，这时候使用里面有设置访问这些私有成员属性的方法“set”、“get”去访问。
【备注】eclipse上有快捷键去直接自动生成“set”、“get”方法的快捷键，首先声明好需要的成员变量，在
代码的空白出右键选择“source”标签，进去找到Generate Getters and Setters，然后选择要生成的成员属性

点击“确定”就可以了。

成员变量的继承
        之前说继承的知识时候，说的方法的继承。除了方法可以继承，成员属性也能继承，但前提条件是取决于它的修饰符。1）public修饰的成员变量public是公开的修饰符，继承它的子类都可以去直接的调用它的成员变量。

演示例子：

public class FatherClass {
	public String str1 = "父类的 public 属性";
}

class SonClass extends FatherClass {
	void print() {
		SonClass son = new SonClass();
		System.out.println("在子类的方法中：");
		// 子类对象继承父类的属性 str1
		System.out.println(son.str1);
	}
}

public class Demo {
	public static void main(String[] args) {
		// 创建子类对象
		SonClass son = new SonClass();
		// 调用相关方法
		son.print();
	}
}

运行结果：

在子类的方法中：
父类的 public 属性
在子类创建子类的对象，通过对象去访问继承父类的成员变量。

2）protected修饰的成员变量
        protected修饰的成员变量，继承它的子类可以访问，不管这个子类是否与父类（portected修饰的）在同一个包文件下，只要是portected修饰的，就可以去继承访问。

演示例子：

package chapter11;//一个包文件
public class FatherClass {
	public String str1 = "父类的 public 属性";
	protected String str2 = "父类的 protected 属性";
}

//注意程序所在的包是不同的
package anotherPak;//另外一个包文件

import chapter11.FatherClass;

public class SonClass2 extends FatherClass {
	void print() {
		SonClass2 son = new SonClass2();
		System.out.println("在子类的方法中：");
		System.out.println(son.str2);
	}
}

package anotherPak;
public class Demo2 {
	public static void main(String[ ] args) {
		SonClass2 son2=new SonClass2();
		son2.print();
	}
}

运行结果：

在子类的方法中：

父类的 protected 属性

3）默认修饰符成员变量
默认修饰符的成员变量，包外的子类不能访问继承父类的默认修饰符的成员变量，包内类可以继承。

演示例子：

package chapter11;
public class FatherClass {
	public String str1="父类的 public 属性";
	protected String str2="父类的 protected 属性";
	String str3="父类默认修饰符的属性";
}
//在不同的包是不能访问的
package anotherPak;
import chapter11.FatherClass;
public class SonClass2 extends FatherClass {
	void print(){
		SonClass2 son=new SonClass2();
		System.out.println("在子类的方法中：");
		//该语句编译错误
		//System.out.println(son.str3);
	}
}
		
package anotherPak;
	public class Demo2
	{
		public static void main(String[ ] args) {
			SonClass2 son2=new SonClass2();
			son2.print();
		}
	}
}

4）private修饰的成员变量
private修饰的成员变量就是私有的，只能在本类中使用，任何的子类都是不能继承的。


成员变量的隐藏
        成员变量是可以隐藏起来的，不过这个隐藏的方式和字面的意思有些不同，也就是说，在父类中有个成员变量名str，子类中也有个成员变量名str，在main方法中，通过父类对象、子类对象分别打印出父类和子类的str，是能分开打印出各自的str变量的，也就是说子类的变量名与父类的变量名相同，子类的变量不会影响到父类的变量。

演示例子：

class Father {
	String str = "父类的 Str 成员变量";
}

class Son extends Father {
	String str = "子类的 Str 成员变量";
}

public class Hidden {
	public static void main(String[] args) {
		// 创建父类对象
		Father father = new Father();
		// 创建子类对象
		Son son = new Son();
		// 分别访问它们的成员变量
		System.out.println("父类对象访问 Str：");
		System.out.println(father.str);
		System.out.println("子类对象访问 Str");
		System.out.println(son.str);
	}
}

运行结果：

父类对象访问 Str：
父类的 Str 成员变量
子类对象访问 Str
子类的 Str 成员变量

如果子类要调用父类的成员变量，通过关键字super来实现：

class Father {
	String str = "父类的 Str 成员变量";
}

class Son extends Father {
	String str = "子类的 Str 成员变量";

	void show() {
		System.out.println(super.str);
	}
}

public class Hidden {
	public static void main(String[] args) {
		// 创建子类对象
		Son son = new Son();
		System.out.println("调用隐藏的父类成员变量");
		// 调用子类的方法
		son.show();
	}
}

小节：
        基本上明白了封装的意思，也明白了一些关于面向对象的思想。具体的运用还是需要在今后的多运行实例才能深入的了解。