JavaSE学习之道：面向对象的三大特征

清疚 2021-09-30 07:00 235阅读 0赞

1.    面向对对象的三大特征：封装、继承、多态；

2.     封装：隐藏对象的属性和实现细节，仅对外公开接口,控制程序中属性的读和修改的访问权限，将抽象得到的数据和行为相结合，形成“类”，其中数据和方法都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问方式来使用类的成员。

封装的基本要求是：把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数（有带参数的构造器时，系统就不会再自动生成不带参数的构造器了）。

** 例如：**家里的电视，结构复杂，里面乱七八糟的零件一大堆，但是电视使用起来就是那么简单，为什么？那是因为创维把电视来了个封装，把对用户不重要的东西用个电视机壳把它装起来了，然后给你个遥控器，通过这个遥控器，你就可以操作这台电视机了。也就是说你不需要理解电视内部的构造原理和工作原理，你只要会按按钮就可以了。

**分析：**封装的必要性，封装可以提高类的安全性，避免其他类修改数据，这个的依据是因为对象可以直接调用该类的属性，已达到通过属性修改数据的目的，例如下所示：

编写一个教师类，要求：

(1)具有属性：姓名、年龄

(2)具有行为：自我介绍

(3)教师的最小年龄要求：22岁

**代码示例：**

**public class** Teacher\{

**public** Stringname;//教员姓名

**public int** age;//年龄

/\*\*

\*返回自我介绍的内容

\*/

**public** Stringintroduction()\{

**return**"大家好！我是"\+name\+"，我今年"\+age\+"岁";

编写一个测试类，要求：实例化一个教员对象，并对其初始化，并在控制台输出该教员的自我介绍，如下所示：

**代码示例：**

**public class** TeacherTest\{

**public static void** main(String\[\]args)\{

Teacherteacher=**new** Teacher();

teacher.name="张三";

teacher.age=9;

System.*out*.println(teacher.introduction());

**结果：**大家好！我是张三，我今年9岁；

分析：因为没对属性进行封装，所以运行结果不满足教员的最小年龄要求，要满足此要求，就需要通过对属性的封装来实现，修改Teacher类如下：

**代码示例：**

**public class** Teacher \{

**private** Stringname;//教员姓名

**private int** age;//年龄

**public int** getAge() \{

**return**age;

**public void** setAge(**int** age) \{

**if** (age < 22) \{

System.*out*.println("错误！最小年龄应为22岁！");

**this**.age = 22;//如果不符合年龄要求，则赋予默认值

\}**else** \{

**this**.age = age;

**public** String getName() \{

**return**name;//返回教员姓名

**public void** setName(String name) \{

**this**.name = name;//设定教员姓名

**public** String introduction() \{

**return**"大家好！我是" +name +"，我今年" +age +"岁";

编写一个测试类，和上面不一样的是，下面的测试是对象调用方法，而不是给对象中的属性赋值。

**public class** TeacherTest\{

**public static void** main(String\[\]args)\{

Teacherteacher=**new** Teacher();

teacher.setName("张三");

teacher.setAge(9);

System.*out*.println(teacher.introduction());

**结果：**错误！最小年龄应为22岁！

大家好！我是张三，我今年22岁；

分析：封装由于隐藏了自己的属性，其他类不能调用private属性，所以使用隐藏属性的唯一途径就是生成get/set方法，供外界调用，这样不仅可以在get/set方法中设置限定代码，而且还有利于程序的维护和模块化；

**问题：我给public属性的也加上set/get方法，不也一样可以限定年龄吗？**

**解答：如果这样的话，那么测试方法中可以用两种方式初始化Teacher对象了，**

**代码示例：（第一种方法） **

**public class** TeacherTest\{

**public static void** main(String\[\]args)\{

Teacherteacher=**new** Teacher();

teacher.name="张三";

teacher.age=-4;

System.*out*.println(teacher.introduction());

**结果：**大家好！我是张三，我今年-4岁

**代码示例：（第二种方法） **

**public class** TeacherTest\{

**public static void** main(String\[\]args)\{

Teacherteacher=**new** Teacher();

teacher.setName("张三");

teacher.setAge(-4);

System.*out*.println(teacher.introduction());

**结果：**错误！最小年龄应为22岁！  
     大家好！我是张三，我今年22岁

分析：这样的话set/get方法中所有的限定就没有用了，别人可以用第一种方法（直接对属性的访问）来修改类的限制功能，所以，封装（私有的属性，共有接口方法）能带来好处；

知识扩展：**使一个对象不可变需要有3个步骤：   **

（1）数据成员必须是私有的，防止被外部的代码直接地操纵。（private）

（2）不能提供setter方式，目的就是不允许对被封装的数据的变更。（可以在类中的属性直接初始化）

（3）类本身必须是最终的，声明类为最终的可以防止另一个类创建不可变类的可变子类。（final关键字：不能被继承）

3. **访问修饰符（access modifier）。**

1） public（公共的）：被public所修饰的属性和方法可以被所有类访问。

2） protected（受保护的）：被protected所修饰的属性和方法可以在类内部、相同包以及该类的子类所访问。

3） private（私有的）：被private所修饰的属性和方法只能在该类内部使用

4） 默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。

4. 如果一个java源文件中定义了多个类，那么这些类中最多只能有一个类是**public**的，换句话说，定义的多个类可以都不是public的。

**5. **方法重载（Overload）。表示两个或多个方法名字相同，但方法参数不同。方法参数不同有两层含义：1）参数个数不同。2）参数类型不同。注意：方法的返回值对重载没有任何影响。

**6.**构造方法重载：只需看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么可以使用this()的方式调用，this()括号中的参数表示目标构造方法的参数。this()必须要作为构造方法的第一条语句，换句话说，this()之前不能有任何可执行的代码。

**       程序示例：**

**package** com.zp.base;

**   public class** ConstructOverload \{

**public** ConstructOverload()\{

**this**(4);//必须写在第一行,调用了第二个带参的构造方法;

System.*out*.println("test");

**public** ConstructOverload(**int**i)\{

System.*out*.println(++i);

**public static void** main(String \[\]args)\{

ConstructOverloadc1 = **new** ConstructOverload();

ConstructOverloadc2 = **new** ConstructOverload(3);

结果：5  test  4

**7.**继承（Inheritence）：Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类【基类】， 继承的类叫做子类），Java中的继承使用**extends**关键字。

**8. **当生成子类对象时，Java默认首先调用父类的不带参数的构造方法，然后执行该构造方法，生成父类的对象。接下来，再去调用子类的构造方法，生成子类的对象。【要想生成子类的对象，首先需要生成父类的对象（**父类得有无参的构造方法**），没有父类对象就没有子类对象。比如说：没有父亲，就没有孩子】。

**       程序示例：**

**package** com.zp.base;

**  public class** Parent \{

**public** Parent()\{

System.*out*.println("parent...");

**package** com.zp.base;

**public class** Child **extends**Parent \{

**public** Child()\{

System.*out*.println("Child...");

**public static void** main(String \[\]args)\{

Childc = **new** Child();

结果：parent...     Child...

子类有参数的构造方法和上述结果一样，这样就能得出：无论子类是什么构造方法，都可以创建父类对象，然后生成子类对象；但是如果将父类的构造器改成有参构造器，如下所示：

**public class** Parent \{

**public** Parent(int a)\{

System.*out*.println("parent...");

则会出现错误如下所示：

Implicit super constructor Parent() is undefined. Must explicitly invokeanother constructor.

**    解决方案：通过在子类构造器中使用super()方法，调用父类带参数构造器**

**    程序示例：**

**public class** Parent \{

**public** Parent(int a)\{

System.*out*.println("parent...");

** **

**    package** com.zp.base;

**public class** Child **extends**Parent \{

**public** Child()\{

super(1); //此处调用父类带参数的构造方法

System.*out*.println("Child...");

**public static void** main(String \[\]args)\{

Childc = **new** Child();

**    结果：**parent...   Child...

** **

**9. **关键字：**super**表示对父类构造方法的调用；**this**表示对当前类的构造器的调用，必须写在构造器的第一条语句上。

**10. **如果子类使用super()显式调用父类的某个构造方法，那么在执行的时候就会寻找与super()所对应的构造方法而不会再去寻找父类的不带参数的构造方法。与this一样，super也必须要作为构造方法的第一条执行语句，前面不能有其他可执行语句。

**11. **关于继承的3点：

a)父类有的，子类也有

b)父类没有的，子类可以增加

c)父类有的，子类可以改变

**程序示例：**

**package** com.zp.base;

**public class** Parent \{

String name ="name = father";

**public** Parent(**int** a)\{

System.*out*.println("parent...");

**public void** say()\{

System.*out*.println("I can say....");

**package** com.zp.base;

**public class** Child **extends** Parent \{

String name ="name = son";

**int** age = 20;

**public** Child()\{

**super**(1);

System.*out*.println("Child...");

**public void** study()\{

System.*out*.println("the son is student....");

**public static void** main(String \[\] args)\{

Child c = **new**Child();

System.*out*.println(c.name);

System.*out*.println(c.age);

c.study();

c.say();

**结果：**parent...

Child...

name = son

the son is student....

I can say....

**12. **关于继承的注意事项

**a) **构造方法不能被继承

**b) **方法和属性可以被继承

**c) **子类的构造方法隐式地调用父类的不带参数的构造方法

**d) **当父类没有不带参数的构造方法时，子类需要使用**super**来显式地调用父类的构造方法，**super**指的是对父类的引用 。

**e) super**关键字必须是构造方法中的第一行语句。

13. 方法重写（Override）：又叫做覆写，子类与父类的方法返回类型一样、方法名称一样，参数一样，这样我们说子类与父类的方法构成了重写关系。

14. 方法重写与方法重载之间的关系：重载发生在同一个类内部的两个或多个方法。重写发生在父类与子类之间。

15. 当两个方法形成重写关系时，可以在子类方法中通过super.say()形式调用父类的say ()方法，其中super. say ()不必放在第一行语句，因此此时父类对象已经构造完毕，先调用父类的run()方法还是先调用子类的say ()方法是根据程序的逻辑决定的。

**程序示例：**

**public class** Parent \{

String name = "name = father";

**public** Parent(**int** a)\{

System.*out*.println("parent...");

**public void** say()\{

System.*out*.println("Parent can say....");

**package** com.sdjz;

**public class** Child **extends** Parent\{

**public** Child(String name) \{

**super**(1);

System.*out*.println("child....");

@Override

**public void** say() \{

System.*out*.println("Child cansay....");

**public void** study()\{

//super用来调用父类方法，可以放在任何位置，这也是和在构造器中的区别；

**super**.say();

System.*out*.println("the son isstudent....");

**super**.say();

**public static void** main(String\[\] args) \{

Child child = **new** Child("zhangpeng");

child.say();

child.study();

**结果：**parent...

child....

Child can say....

Parent can say....

the son is student....

Parent can say....

分析：使用super调用父类方法的时候，如果没有重写父类方法，这时候就没有和父类方法重名的方法了，子类就可以直接调用父类的方法了，但是在子类重写父类方法的时候就只能用super调用父类方法了；

**代码示例：**（父类和上面代码一样）

**public class** Child **extends** Parent\{

**public** Child(String name) \{

**super**(1);

System.*out*.println("child....");

**public void** study()\{

say();

**public static void** main(String\[\] args) \{

Child child = **new** Child("zhangpeng");

child.study();

**结果：**parent...

child....

Parent can say....

16. 在定义一个类的时候，如果没有显式指定该类的父类，那么该类就会继承于java.lang.Object类（JDK提供的一个类，Object类是Java中所有类的直接或间接父类）。

**17. **多态（Polymorphism）：即多种形态；我们说子类就是父类（玫瑰是花，男人是人），因此多态的意思就是：父类型的引用可以指向子类的对象。

** **

**程序示例：**

**package** com.zp.base;

**public class** Parent \{

**public void** say()\{

System.*out*.println("parent cansay....");

** **

**package** com.zp.base;

**public class** Child **extends** Parent \{

**public void** say()\{

System.*out*.println("child cansay....");

**public static void** main(String \[\] args)\{

Parent c = **new** Child();//**多态：父类应用指向子类对象**

c.say();

**18. **Parent p = new Child();当使用多态方式调用方法时，首先检查父类中是否有say()方法，如果没有则编译错误；如果有，再去调用子类的**say()**方法，若子类没有则调用父类的say()方法，p是父类引用，所以是Parent类型的，只是指向了Child类型，只能调用父类有的方法。

19. 一共有两种类型的强制类型转换：

a) 向上类型转换（upcast）：比如说将Cat类型转换为Animal类型，即将子类型转换为父类型。对于向上类型转换，不需要显式指定。

b) 向下类型转换（downcast）：比如将Animal类型转换为Cat类型。即将父类型转换为子类型。对于向下类型转换，必须要显式指定（必须要使用强制类型转换）。

示例：Parent p = new Child(); //向上类型转换;

p= new Parent();

Child c = (Child)p; //向下类型转化;

**20. 一个突出多态简便作用的例子：**

** **

**package** com.zp.duotai;

**public class** Car \{

**public void** run()\{

System.*out*.println("Car isruning....");