面向对象的特点，封装性，继承性，多态性！

1.面向对象程序设计有三大特点，分别是封装，继承，多态，接下来就介绍一下这三个特点，积累一下。

2.封装，封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体是类，类通常对用户隐藏其实现的细节，这就是封装的思想，在Java中通常通过建立一个实体类，用来封装对象的属性和行为，通过setXxx()和getXxx()方法封装起来，例如，用户在使用一款软件的时候，只需知道如何使用软件，点击某个按钮就可以实现一定的功能，用户不需要知道软件是如何被开发出来的，软件内部是如何工作的，在使用该软件时不依赖于开发时的细节和软件内部工作的细节。

采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易直接操纵该数据结构，而只能执行该类允许公开的数据。这样可以避免外部对内部数据的影响，提高程序的可维护性。

总结一下，封装性就是利用抽象数据类型将数据和基于数据的操作封装在一起，保护数据并隐蔽具体的细节，只保留有限的接口与外界联系。

接下来附上一个封装的例子，定义一个实体类，声明属性为私有的，通过setXxx()和getXxx()的公共方法来封装数据(即封装属性)，利用this关键字来引用成员变量，最后通过建立一个测试类来调用setXxx()和getXxx()方法，其中实体类中有两个构造方法，一个为无参构造方法，一个为有参构造方法，代码如下所示：

Student.java文件，实体类代码：

package tom.bean;

/*
 * 学生实体类
 */
public class Student {
	private String name;// 声明一个私有字符串变量，表示姓名
	private int age;// 声明一个私有整型变量，表示年龄
	private String sex;// 声明私有一个私有字符串变量，表示性别
	private String major;// 声明一个私有字符串变量，表示专业

	public Student() { // 无参构造方法
	}

	public Student(String name, int age, String sex, String major) { // 有参构造方法
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.major = major;
	}

	public String getName() {	//获得姓名的方法
		return name;
	}

	public void setName(String name) {	//设置姓名的方法
		this.name = name;
	}

	public int getAge() {	//获得年龄的方法
		return age;
	}

	public void setAge(int age) {	//设置年龄的方法
		this.age = age;
	}

	public String getSex() {	//获得性别的方法
		return sex;
	}

	public void setSex(String sex) {	//设置性别的方法
		this.sex = sex;
	}

	public String getMajor() {	//获得专业的方法
		return major;
	}

	public void setMajor(String major) {	//设置专业的方法
		this.major = major;
	}

}

Test.java文件，测试类代码：

 

package tom.test;

import tom.bean.Student;

public class Test {
	public static void main(String[] args){
		Student student=new Student();//实例化Student对象
		/*设置各个属性的内容*/
		student.setName("Lc");
		student.setAge(22);
		student.setSex("男");
		student.setMajor("软件工程专业");
		/*获得学生各个属性的内容，打印输出信息*/
		System.out.print("第一位学生的信息如下:"+"\n"+"姓名为"+student.getName());
		System.out.print(",年龄为"+student.getAge());
		System.out.print(",性别为"+student.getSex());
		System.out.print(",专业为"+student.getMajor());

		Student student1=new Student("123nh", 21, "女", "英语专业");
		System.out.print("\n");
		System.out.print("第二位学生的信息如下:"+"\n"+"姓名为"+student1.getName());
		System.out.print(",年龄为"+student1.getAge());
		System.out.print(",性别为"+student1.getSex());
		System.out.print(",专业为"+student1.getMajor());
	}
}

运行测试类后结果如下：

3.继承性，简单来说就是使子类的对象拥有父类的全部属性和行为，同时可以增添自己的所特有的属性和行为。这样可以节省写共同具有的属性和方法代码的时间，有利于代码的复用，这就是继承的基本思想。软件的代码使用继承思想可以缩短软件开发的时间，复用那些已经定义好的类可以提高系统和软件的性能，减少系统和软件在使用过程中出现错误的几率。一个类可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法，子类的实例都是父类的实例，但不能说父类的实例是子类的实例。

继承的实现，在Java语言中，继承通过extends关键字来实现，用这个extends关键字时指明当前的类为子类，并指明从哪个类继承而来，即在子类的声明中，通过使用extends关键字来指明其父类，其基本格式如下：

修饰符 class 子类名 extends 父类名{

类体

}

接下来附上一个小例子，定义一个People类，其中有姓名，年龄和性别属性和setXxx()和getXxx()的方法，作为父类，在定义一个Student类，继承于父类，作为子类，在子类中只定义2个属性，一个学号，一个专业，再定义一个Test测试类，实例化子类，利用子类对象调用父类的属性和方法，具体见代码：

目录结构如下图：

People.java文件代码：

package tom.bean;

/*
 * 定义一个人类，作为Student的父类
 */
public class People {
	private String name;//声明一个私有变量，表示姓名
	private int age;//声明一个私有变量，表示年龄
	public String sex="男";//声明一个公有变量，表示性别，初始化为男

	public People() {	//无参构造方法
	}

	public String getName() {	//获得姓名方法
		return name;
	}

	public void setName(String name) {	//设置姓名方法
		this.name = name;
	}

	public int getAge() {	//获得年龄方法
		return age;
	}

	public void setAge(int age) {	//设置年龄方法
		this.age = age;
	}

	public String getSex() {	//获得性别方法
		return sex;
	}

	public void setSex(String sex) {	//设置性别方法
		this.sex = sex;
	}


}

Student.java文件代码：

package tom.bean;

/*
 * 定义一个学生类，继承于人类，作为子类
 */
public class Student extends People{
	private String stuId;//声明一个变量，表示学号
	private String major;//声明一个变量，表示专业

	public Student(){	//定义无参构造方法		
	}

	public String getStuId() {	//获得学号方法
		return stuId;
	}

	public void setStuId(String stuId) {	//设置学号方法
		this.stuId = stuId;
	}

	public String getMajor() {	//获得专业方法
		return major;
	}

	public void setMajor(String major) {	//设置专业方法
		this.major = major;
	}


}

Test.java文件的代码：

package tom.test;

import tom.bean.Student;

/*
 * 测试类，实例化子类，调用父类的属性和方法，也调用自己所特有的方法
 */
public class Test {
	//主方法
	public static void main(String[] args) {
		Student student = new Student();//实例化Student类
		student.setName("Xg");//调用父类People类的设置姓名的方法
		student.setAge(22);//调用父类People类的设置年龄的方法
		student.setStuId("2012131735");//调用Student类的设置学号的方法
		student.setMajor("软件工程");//调用Student类的设置专业的方法
		/*打印输出学生信息*/
		System.out.println("学生信息如下：");
		System.out.print("姓名为"+student.getName());
		System.out.print("，年龄为"+student.getAge());
		System.out.print("，性别为"+student.sex);
		System.out.print("，学号为"+student.getStuId());
		System.out.print("，专业为"+student.getMajor());
	}
}

运行Test.java文件后，结果如下图所示：

4.多态性，简单来说就是一个程序中同名的多个不同方法共存的情况，通常使用方法的重载和重写（也叫覆盖）来实现类的多态性，多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类以及相关类，多态的实现并不依赖具体类，而是依赖抽象类和接口，在多态的机制中，父类通常会被定义为抽象类，在抽象类中给出一个方法的标准，而不给出实现的具体过程，通过继承父类来实现，而比抽象类更方便的是将抽象类定义为接口。这里先暂时介绍到这里，多态中使用方法的重写和重载以后在专门写一篇文章！以免这篇文章篇幅过长！

5.以上就是面向对象程序设计的三大特点，仅供大家学习参考，写得不好请见谅，如有错误请指出，谢谢！