面向对象的特点,封装性,继承性,多态性!

时间:2023-02-24 18:01:20

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.以上就是面向对象程序设计的三大特点,仅供大家学习参考,写得不好请见谅,如有错误请指出,谢谢!