【注意,本人小白一个,以下是个人根据教程的理解,如有疑惑,出错的地方,希望大家能够留言指出来,相互学习进步。】
封装性
封装是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();
}
}
小节:
基本上明白了封装的意思,也明白了一些关于面向对象的思想。具体的运用还是需要在今后的多运行实例才能深入的了解。