Java基础1：Java面向对象的三大特性+重写和重载

本是古典何须时尚 2021-12-08 22:13 211阅读 0赞

封装、继承、多态

一、面向对象思想

单独谈面向对象，理解起来并不深刻。在面向对象之前的编程是面向过程的，主要的描述一个具体行为的发展过程，比如回正对洗手这个动作进行编程，某人先涂洗手液，搓洗，清水冲，当我们需要修改某人，或者修改洗手液的品牌就需要修改代码，这要就不符合“对更改封闭，对扩展开放”的原则。所以就发展到面向对象编程。对象可以理解为一个执行者，编程的时候重点是这个对象，例如对象是人，人的性别、年龄、身高是他的属性，他的行为可以洗手、吃饭、逛街等等。这给时候想添加新的行为就可以在对象中扩展一个新的方法，无需更改代码。当我们想换个人的时候就可以把共同属性、行为抽取出来形成一个类，比如人类这个类，具体的人可以继承这个类，自己独特的行为、属性可以扩展。但是继承的耦合性太强，子类与父类的联系太过紧密，这个时候就出现多态。类的某些方法、属性不希望其他类访问，这就需要封装。

二、封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

个人理解，封装主要是因为Java有访问权限的控制。public > protected > package = default(包访问权限) > private。封装可以保护类中的信息，只提供想要被外界访问的信息。

![1737730-20190712094702962-360213420.png][]

可以看一下这个博客：[https://www.cnblogs.com/jinggod/p/8425423.html][https_www.cnblogs.com_jinggod_p_8425423.html]

三、继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

1、被private修饰的，是不可以被继承的，因为private修饰的只能在本类中可见，子类是不可见的；另外父类被protected或public修饰的，子类是可以继承的；被默认修饰符修饰的只能在同包下的子类是可以继承的；

2、构造器是不会被子类继承的，但子类的对象在初始化时会默认调用父类的无参构造器，当父类显示写了有参构造器，且没有无参构造器。子类继承父类的时候必须显示的调用父类的有参构造器。调用的方式可以使用super(a,b)来调用；

3、子类是不会继承父类被static修饰的方法和变量，但是可以调用。

4、Java中的继承只能单继承，但是可以通过内部类继承其他类来实现多继承。

四、多态

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

![dt-java.png][]

多态性是对象多种表现形式的体现。

public class Test {
        public static void main(String[] args) {
          show(new Cat());  // 以 Cat 对象调用 show 方法
          show(new Dog());  // 以 Dog 对象调用 show 方法
                    
          Animal a = new Cat();  // 向上转型  
          a.eat();               // 调用的是 Cat 的 eat
          Cat c = (Cat)a;        // 向下转型  
          c.work();        // 调用的是 Cat 的 work
      }  
                
        public static void show(Animal a)  {
          a.eat();  
            // 类型判断
            if (a instanceof Cat)  {  // 猫做的事情 
                Cat c = (Cat)a;  
                c.work();  
            } else if (a instanceof Dog) { // 狗做的事情 
                Dog c = (Dog)a;  
                c.work();  
            }  
        }  
    }
     
    abstract class Animal {  
        abstract void eat();  
    }  
      
    class Cat extends Animal {  
        public void eat() {  
            System.out.println("吃鱼");  
        }  
        public void work() {  
            System.out.println("抓老鼠");  
        }  
    }  
      
    class Dog extends Animal {  
        public void eat() {  
            System.out.println("吃骨头");  
        }  
        public void work() {  
            System.out.println("看家");  
        }  
    }
    
    
    执行以上程序，输出结果为：
    吃鱼
    抓老鼠
    吃骨头
    看家
    吃鱼
    抓老鼠

五、重写和重载。

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

**　　**重载是在一个类里面，方法名字相同，而参数不同（数量和类型可以不同）。返回类型可以相同也可以不同**。**

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

*  (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
 *  (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
 *  (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

![overloading-vs-overriding.png][]

![20171102-1.jpg][]

转载于:https://www.cnblogs.com/JimShi/articles/11174593.html

[1737730-20190712094702962-360213420.png]: /images/20211209/5cfada28ddf0437f9af983e2f74aba45.png
[https_www.cnblogs.com_jinggod_p_8425423.html]: https://www.cnblogs.com/jinggod/p/8425423.html
[dt-java.png]: /images/20211209/fa41f671d550486db328f32a2bc36f83.png
[overloading-vs-overriding.png]: /images/20211209/c8e7e7da19cd4f5ebf44e5c09635ec56.png
[20171102-1.jpg]: /images/20211209/db2b2c9f4f7e4a83907149d1aed50edb.png