Java面向对象的三个特性（封装性、继承性、多态性）_java面向对象的三大特性

Java面向对象的三大特性（封装性、继承性、多态性）

首先我们再来提一下面向对象：

面向对象是一种符合人类思维习惯的编程思想，显示生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系（每种事物都具备自己的属性和行为）。在程序中使用对象来映射现在中的事物，使用对象的关系来描述事物之间的关系，这种思想就是面对对象的思想。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。

类和对象的描述:（类和对象(转载)）

面向对象的三个特性

1 封装性

封装面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体的实现细节，这就是封装的思想。将属性隐藏起来，若需要访问某个属性，需要用自己这个类提供对应的行为（方法）来读取和修改。

1.1封装思想

1. 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变 量都是隐藏在对象内部的，外界是无法直接操作的
2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操 作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

1.2 封装的步骤

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

Java 中属性的封装，无特殊情况都是用的 private 修饰符， 用 private 修饰符声明该属性为私有属性，只允许类的内部直接访问该属性。对于私有属性，要给一对 setter() 和 getter() 方法操作，外部访问私有属性需要通过setter() 和 getter() 方法。 setter() 和 getter() 方法 IDE 可快速生成(快捷键-alt+insert ) 。

1.3 private修饰符的含义

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。
补充：权限修饰符

1.4private的使用格式

private  数据类型 变量名 ；
1

使用 private 修饰成员变量，代码如下：

//定义成员变量
private String name;
private int age;
private char gender;


1
2
3
4
5
6

提供 getXxx 方法 / setXxx 方法，可以访问(获取，修改)成员变量

// get/set方法
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 char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
    //用Alt+Insert快捷键自动生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2 继承性

继承主要描述的是类与类之间的关系 ，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然可以修改扩充子类的属性和方法来满足需求。

2.1 继承的含义：

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。
继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

2.2 继承的好处

1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。
2. 使类与类之间产生了关系。

2.3 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类{
  ...
}
class 子类 extends 父类{
}
1
2
3
4
5

需要注意：Java是单继承的，一个类只能继承一个直接父类（一个儿子只能有一个亲爹），跟现实世界很像，但是Java中的子类是更加强大的。

2.4 关键字 ：extends

关键字 extends 表明正在构造的新类派生于一个已存在的类。已存在的类被称为超类（super class）、基类（base class）或父类（parent class）；新类被称为子类（subclass）、派生类（derived class）或孩子类（child class）。

2.5小结

继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。超类并不是因为它位于子类之上而拥有比子类更多的功能。恰恰相反，子类比超类拥有的功能更加丰富。

2.6 子类不能继承的内容

子类不能继承父类的构造器，因为子类有自己的构造器。（构造方法名必修与类型相同）
值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

子类可以访问父类的 public 和 protected成员，四种访问属性在和子类中的含义如下。

2.7 继承后的特点

2.7.1成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

2.7.2成员变量重名

子父类中出现了同名的成员变量时，子类会优先访问自己对象中的成员变量。

2.7.3成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

2.7.4成员方法重名

成员方法重名
如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。

2.7.5 构造器

1. 构造器的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造器的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子 类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使 用。（先有爸爸，才能有儿子）
   继承后子类构造器特点:子类所有构造器的第一行都会先调用父类的无参构造器，再执行自己

小结

子类构造器执行的时候，都会在第一行默认先调用父类无参数构造器一次。
子类构造器的第一行都隐含了一个super()去调用父类无参数构造器，super()可以省略不写

2.8 方法的重写

2.8.1 概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

2.8.2 @Override重写注解

@Override:注解，重写注解校验！ 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

2.8.3 注意事项

1. 方法重写是发生在子父类之间的关系。
2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。（四大权限修饰符）
3. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。（标签）

2.8.4 super和this的用法格式

 this.成员变量 -- 本类的 
 super.成员变量 -- 父类的
  this.成员方法名() -- 本类的 
  super.成员方法名() -- 父类的
  
 
1
2
3
4
5
6

调用构造器格式：

super(...) -- 调用父类的构造器，根据参数匹配确认
this(...) -- 调用本类的其他构造器，根据参数匹配确认

1
2
3

注意： 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和
this() 都必须是在构造方法的第一行，所以不能同时出现。 super(…)是根据参数去确定调用父类哪个构造器的。
super 关键字有两个用途：一是调用超类的方法，二是调用超类的构造器。super 不是一个对象的引用，不能将 super 赋给另一个对象变量，它只是一个指示编译器调用超类方法的特有关键字。

小结

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的 super()。 super() 和
this() 都必须是在构造方法的第一行，所以不能同时出现。 super(…)和this(…)是根据参数去确定调用父类哪个构造器的。
super(…)可以调用父类构造器初始化继承自父类的成员变量的数据。 this(…)可以调用本类中的其他构造器。

2.9 继承的特点

1. Java只支持单继承，不支持多继承。

// 一个类只能有一个父类，不可以有多个父类。
 class A {} 
 class B {} 
 class C1 extends A {} // ok 
 // class C2 extends A, B {} // error
1
2
3
4
5

2. 一个类可以有多个子类。

// A可以有多个子类
 class A {} 
 class C1 extends A {}
 class C2 extends A {}
1
2
3
4

3. 可以多层继承。

class A {} 
class C1 extends A {} 
class D extends C1 {}
1
2
3

*顶层父类是Object类。所有的类默认继承Object，作为父类。

3 多态性

多态性指的是在程序中允许出现重名现象，它指的是在一个类中定义的属性和方法被其它类继承后，他们可以具体有不同的数据类型活表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义
比如英语单词，在不同的环境下有不同的意思，这里不举例，找一个自己理解的单词，去体会它的多重含义。

3.1定义

多态： 是指同一行为，具有多个不同表现形式。

3.2多态的前提

#1. 继承或者实现【二选一】
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】

3.3 多态的格式

父类类型 变量名 = new 子类对象； 
变量名.方法名();

Fu f = new Zi(); 
f.method();
//父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
1
2
3
4
5
6

定义父类：

public abstract class Animal { 
	public abstract void eat(); 
}
1
2
3

定义子类：

class Cat extends Animal { 
	public void eat() { 
		System.out.println("吃鱼"); 
	}
 }
 class Dog extends Animal { 
 	public void eat() { 
		 System.out.println("吃骨头"); 
	}
}
1
2
3
4
5
6
7
8
9
10

定义测试类：

public class Test { 
	public static void main(String[] args) { 
		// 多态形式，创建对象
		Animal a1 = new Cat(); 
		 // 调用的是 
		Cat 的 eat a1.eat(); 
		 
		 // 多态形式，创建对象
	 	Animal a2 = new Dog(); 
	 	// 调用的是
	  	Dog 的 eat a2.eat(); 
	 } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写=后方法。
多态在代码中的体现为父类引用指向子类对象。

3.4 引用类型转换

多态的转型分为向上转型与向下转型两种：

3.4.1向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。 当父类引用指向一个子类对象时，便是向上转型。

3.4.2向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

为什么要转型

*当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下：
定义类：

abstract class Animal { 
	abstract void eat(); 
	}
class Cat extends Animal { 
	public void eat() { 
		System.out.println("吃鱼");
	}
	public void catchMouse() { 
		System.out.println("抓老鼠"); 
	} 
}
class Dog extends Animal { 
	public void eat() {
		 System.out.println("吃骨头"); 
	}
	public void watchHouse() {
		 System.out.println("看家"); 
	} 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

定义测试类：

public class Test {
	 public static void main(String[] args) { 
	 // 向上转型 
	 Animal a = new Cat(); 
	 a.eat();  // 调用的是 Cat 的 eat 
	
	 // 向下转型 
	 Cat c = (Cat)a;
	 c.catchMouse(); // 调用的是 Cat 的 catchMouse } }
1
2
3
4
5
6
7
8
9

转型的异常
我来先来看这段代码

public class Test {
	 public static void main(String[] args) { 
	 // 向上转型 
	 Animal a = new Cat(); 
	 a.eat();  // 调用的是 Cat 的 eat 
	
	 // 向下转型 
	 Dog d = (Dog)a;
	 d.catchMouse(); // 调用的是 Dog 的 watchMouse } }
1
2
3
4
5
6
7
8
9

首先这段代码在编译时是可以通过的不会报红，但是如果运行就会报错ClassCastException(类型转换异常)
原因是创建的是Cat类对象，当然不能转成Dog类对象，这两个对象之间没有继承关系，为了避免错位的发生，
java为我们提供了一个instanceof关键字，来给引用类型做类型的校验。
instanceof使用格式：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

public class Test {
 public static void main(String[] args) {
  	// 向上转型
  	 Animal a = new Cat(); 
  	 a.eat();            // 调用的是 Cat 的 eat
    // 向下转型 
    if (a instanceof Cat){ 
   		Cat c = (Cat)a; 
    	c.catchMouse(); // 调用的是 Cat 的 catchMouse 
    } else if (a instanceof Dog){ 
    	Dog d = (Dog)a;
    	d.watchHouse(); // 调用的是 Dog 的 watchHouse } } }
1
2
3
4
5
6
7
8
9
10
11
12

小结：多态向上转型是将子类类型转成父类类型，多态向下转型是将父类类型转成子类类型。

等有空会继续补充内容，面向对象思想靠看是无法理解透彻的，所以让我们一起用大量的代码来练习吧！！！