面向对象的三大特征
面向对象的三大特征
- 一、封装
-
- 1、封装含义
- 2.四种权限访问修饰符
- 二、继承
-
- 1.继承的概念
- 2.类的继承格式
- 3.继承的好处
- 4.继承的特性
- 5.继承关键字
-
- （1）super 关键字
-
- super关键字的使用：
- 格式：
- super调用构造器
- （2）final关键字
- 三、多态
-
- 1.什么是多态
- 2.多态的使用
一、封装
1、封装含义
所谓类的封装是指在定义一个类时，将类中的属性私有化，即用private关键字来修饰，为了能让外界访问私有属性，需要提供一些public修饰的公共方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。
举例：
import java.util.*;
class Student {
private String name;
private String sex;
private int age;
//下面是公有的getXxx()和setXxx()方法
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 void introduce(){
//打印属性name和age的值
System.out.println( name +"是男生"+age +"岁！");
}
}
public class TestDemo {
public static void main(String args[]) {
Student per = new Student();// 声明并实例化对象
Student stu = new Student(); //创建学生对象
stu.setName("张三"); //利用set方法为name属性赋值
stu.setAge(18); //利用set方法为age属性赋值
System.out.println(stu.getName());//利用get方法获取Name的值
System.out.println(stu.getAge());//利用get方法获取Age的值
//调用对象的introduce()方法
stu.introduce();
}
}
运行结果：
张三
18
张三是男生18岁！
Process finished with exit code 0
2.四种权限访问修饰符
封装性的体现，需要权限修饰符来配合。
- Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
- 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
具体权限如下：
拓展（缺省定义方式）：
class TestDemo {
//“缺省”修饰的方法
void test(){
System.out.println("hello world");
}
public static void main(String[] args) {
TestDemo dt =new TestDemo();
dt.test();
}
}
二、继承
1.继承的概念
继承的主要作用在于，在已有基础上继续进行功能的扩充。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
2.类的继承格式
类的继承格式
class 父类 {
}
class 子类 extends 父类 {
}
3.继承的好处
- 继承的出现减少了代码冗余，提高了代码的复用性。
- 继承的出现，更有利于功能的扩展。
- 继承的出现让类与类之间产生了关系，提供了多态的前提
我们可以通过下面一段代码来深入理解:
package study.day_11;
class Person1 {
String name;
int age;
public Person1() {
}
public Person1(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
class Student1 {
String name;
int age;
String major;
public Student1(){
}
public Student1(String name, int age, String major) {
this.name = name;
this.age = age;
this.major = major;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void study(){
System.out.println("学习 ");
}
}
public class Person{
public static void main(String[] args) {
}
}
从以上可看出，含有大量重复的代码，java语言一般不允许大量重复的代码出现，这段代码不仅从代码上重复，而且从概念上讲学生一定是人，只是学生类描述的范围小，具备更多的属性和方法，这个时候想要消除结构定义上的重复，就要用到继承。
所以可将上述代码改为：
class Person1 {
String name;
int age;
public Person1() {
}
public Person1(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
class Student1 extends Person1{
String major;//专业
public Student1(){
}
public Student1(String name, int age, String major) {
this.name = name;
this.age = age;
this.major = major;
}
public void study(){
System.out.println("学习 ");
}
}
public class TestDemo{
public static void main(String[] args) {
System.out.println("Student类*************");
Student1 s1=new Student1();
s1.name="张三";
s1.age=18;
s1.major="Java语言";
System.out.println("姓名："+s1.name+"年龄："+s1.age+"专业："+s1.major);
}
}
运行结果：
Student类*************
姓名：张三年龄：18专业：Java语言
Process finished with exit code 0
4.继承的特性
- 子类拥有父类非 private 的属性、方法。
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- Java 的继承是单继承，每个子类只有一个父类。
- 子类直接继承的父类，称为：直接父类，间接继承的父类称为：间接父类。子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
5.继承关键字
（1）super 关键字
super关键字的使用：
1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器
格式：
1.我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
2.特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
super调用构造器
1.我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
2 ."super(形参列表)"的使用，必须声明在子类构造器的首行！
3.我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现
4. 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
5.在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器
举例：
class people {
void eat() {
System.out.println("人吃饭");
}
}
class Men extends people {
void eat() {
System.out.println("张三吃饭");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class TestDemo11_4 {
public static void main(String[] args) {
people a = new people();
a.eat();//打印people父类中eat方法
Men d = new Men();
d.eatTest();//打印子类Men中eatTest方法
}
}
运行结果：
人吃饭
张三吃饭
人吃饭
（2）final关键字
final 关键字声明类可以把类定义为不能继承的；或者用于修饰方法，该方法不能被子类重写
*声明类：
final class 类名 {//类体}
*声明方法：
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体};
三、多态
1.什么是多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
打印这个行为具有彩色打印和黑白打印两种不同的表现形式。
2.多态的使用
1.对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
2. 多态的使用：虚拟方法调用：
- 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
- 总结：编译，看左边；运行，看右边。
3.多态性的使用前提： ① 类的继承关系 ② 方法的重写
4. 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
以下是一个多态实例的演示，详细说明请看注释：
Person类：
package study.day_13.java;
public class Person {
String name;
int age;
int id = 1001;
public void eat(){
System.out.println("人：吃饭");
}
public void walk(){
System.out.println("人：走路");
}
}
Man类：
package study.day_13.java;
public class Man extends Person{
boolean isSmoking;
int id = 1002;
public void earnMoney(){
System.out.println("男人负责挣钱养家");
}
public void eat(){
System.out.println("男人多吃肉，长肌肉");
}
public void walk(){
System.out.println("男人霸气的走路");
}
}
Woman类：
package study.day_13.java;
public class Woman extends Person{
boolean isBeauty;
public void goShopping(){
System.out.println("女人喜欢购物");
}
public void eat(){
System.out.println("女人少吃，为了减肥");
}
public void walk(){
System.out.println("女人窈窕的走路");
}
}
测试类：
public class PersonTest {
public static void main(String[] args) {
System.out.println("Person类eat方法**********");
Person p1 = new Person();
p1.eat();
System.out.println("Man类方法*************");
Man man = new Man();
man.eat();
man.earnMoney();
//*************************************************
System.out.println("多态*******************");
//多态：子类的对象赋给父类的引用（父类的引用指向子类的对象）
Person p2 = new Man();
//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
p2.eat();
p2.walk();
/**
*p2.earnMoney();
*有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型
* 编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
**/
}
}
运行结果：
Person类eat方法**********
人：吃饭
Man类方法*************
男人多吃肉，长肌肉
男人负责挣钱养家
多态*******************
男人多吃肉，长肌肉
男人霸气的走路