OOP(面向对象编程)基础二 —— Java语言

在上一篇博客中，我们总结了OOP中的类的一些基本定义。

在java中有许多的类，因此存在一些类之间有继承的关系。那么什么是继承呢？

 一.继承

在面向对象程序设计中，可以在已有的类的基础上定义新的类，而不需要把已有类的内容再写一遍，这就叫做继承。

例子：

   举一个生活中的例子：电脑是一个类，电脑可以用来上网。那么台式机，笔记本等就是电脑的子类，它们都可以用来上网。

 

我们为什么要使用继承呢？

1.  方便，少用很多重复的代码（提高代码的重用性）。
2. 提高程序的扩展性。

  了解了什么是继承和使用继承的原因，我们现在看一下java继承的语法格式。

      java继承的关键字：extends 

      格式：

 public class 类名(子类名或超类名) extends 类名(父类名或基类名){
         //代码
}

    注意：子类继承父类后，那么必须要有一个参数个数，参数类型和参数顺序和父类构造函数完全相同的构造函数。

 

     例子：public class UNStudent extends Student{}

   在这个继承中如果Student类中存在一个构造函数：

public Student(String name){
	this.name = name;
 }

 

  那么在子类UNStudent中必须存在这样的一个构造函数：

 public UNStudent(String name) {
	super(name);
                  //super关键字表示的是要调用父类中带一个字符串参数的构造方法。
}

 

 我们定义了一个继承了父类的子类，那么子类与父类存在什么样的关系呢？也就是：

 子类能继承到父类的那些方法和属性呢？

        子类能继承到父类所有的属性和方法(构造方法除外)。

 子类继承了属性和方法那些是能够使用的呢？

       子类能使用父类中的一个部分方法和属性：

                   1.公有的属性和方法

                   2.受保护的属性和方法

                   3.默认的属性和方法（不写访问修饰符的属性和方法）

 

   例子：同样是Student 和UNStudent的例子：

public class Student {
     private String name;//定义一个姓名属性
     private double score;//定义一个学分属性
     public void study(){
        score++;
	System.out.println(name+"正在学习中，学分是"+score);
     }
}

 

相应地定义子类

public class UNStudent extends Student {}

 

此时，UNStudent继承了Student中所有的属性和方法，但是可以使用的只有study()这个方法。

 

二.当父类和子类都相同的方法，但是子类中方法的具体实现和父类不同时，可以使用方法的重写。

方法的重写：

重写的条件是：

           1.方法的返回值数据类型、方法名、参数个数、参数类型以及参数顺序都必须要和父类的完全相同。

           2.子类在重写方法时，方法的访问修饰符可以大于或者等于父类方法的访问修饰符。

           public -->  protected 默认的 --> private

 例子：同上一个例子

在Student的类中有这样的一个学习方法： 

public void study(){
	score++;
	System.out.println(name+"正在学习中，学分是"+score);
}

那么在UNStudent子类要使用另一个study()方法，方法的定义如下：

public void study(){
	System.out.println(this.getName()+"的学习方式不同啦！");
}

在生活中存在有类似的例子：

电脑包括：台式机和平板电脑。电脑可以上网是一个方法，台式机的上网方法相同，而平板电脑的上网可以用触屏来使用，那么平板电脑的上网就是一种重写。

 

三. 方法重写后调用：

 根据实例化的对象，而进行不同的调用，如果实例化的对象是子类的，那么就会优先执行子类中定义或重写方法，如果子类中没有这些方法，则调用父类中的方法。

UNStudent un = new UNStudent("孙哥");
//调用方法以及属性
un.study(5);
//调用时会判断，优先执行了子类中的study()方法。

 

因为存在有子类和父类两个类，那么在实例化对象的过程中就会存在自动转型。

   条件：要实现自动转型就必须要存在继承关系。

  格式一：

    父类名  对象名 = new 子类名();

Student stu = new UNStudent();

 

  还有一种特殊但是重要的自动转型。我们先举一个现实生活中的例子： 

     教大学生英语的老师,ta教的是大学生，那么这老师是否可以教小学生?能不能教初中生，那么高中生，其他类型的学生呢？

public class Teacher {
     /**
      * 定义一个教学的方法
      * @param stu是一个父类类型的参数，这样就表示可以接受所有Student以及Student子   类的对象。
      */
      public void teach(Student stu){
	    System.out.println(name+"在教"+stu.getName()+"学习英语！");
	    stu.study();//学生调用自己的学习方法
      }
}

 

在teach这个方法中传递了一个父类Student中stu这个对象，这样就表示可以接受所有Student以及Student子类的对象。

 

那么：在定义方法中就存在自动转型

  格式二：

public 返回值数据类型  方法名(父类名  对象名){
	//调用在父类中定义过的方法
}

 

 实例化对象可以：

            1．父类名  对象名A = new 子类名();

            2．子类名  对象名B = new 子类名();

 调用方法：

            1．方法名(对象名A);

            2．方法名(对象名B);

那么自动转型的优点就是：

     节省重复的不必要的代码。

 

 

四.多态： 

我们了解了java类的继承，那么就会存在由方法重载，继承，方法重写，自动转型等技术点所以引起的一些列问题——多态。

 存在多态的原因：

   Java在编译的时候并不能确定最终要执行的方法是哪一个；只会根据对象名的类型去判断，调用的方法存不存在，如果这个方法在对象名的类中不存在，则跑出语法错误。

   Java只有在运行的那一刻才能知道最终要执行的方法是哪一个。

 

本篇博文讲解了类的继承以及关于继承的一些知识点，谢谢大家。