Java—继承、封装、抽象、多态

类、对象和包

1） 面向对象编程（Object Oriented Programming ，简称 OOP）：20世纪70年代以后开始流行。

2） 结构化编程与面向对象编程的区别：

A. 在结构化编程中，程序主要围绕着解决的任务来设计。编写程序就是编写执行特定任务的过程，过程中需要用到的数据通过过程参数传递到过程中。过程可以查看以及改变传递进来的数据，并可以将值返回给调用它的过程。

B. OOP主要围绕着解决的问题中的对象来设计，对于每个对象，我们会编写一个类来描述对象的属性和行为。

3） 对象和类

A. 对象：“万物皆对象”、对象由属性和行为组成，属性是对象所具有的特征，行为是对象可以做到动作。

B. 类：类是具有相同属性和行为的一组对象的集合。对象的每个属性被表示为类中的一个成员变量，每个行为成为类中的一个方法。

C. 两者关系：类是对象的抽象（描述），对象是类的实例。

4） 成员变量和局部变量

A. 成员变量：在类中声明的变量，有默认值，可以用在一个类的所有地方。
一个对象的成员变量的初始值  成员变量的数据类型       初始值
         a. 成员变量组成部分：

— 访问修饰符（public 公用的、private 私有的、protected 受保护的、默认的）

— 数据类型

— 成员变量名称（必须是一个有效的标识符）。后面用分号结束
例如：
/**
 * 学生
 *
 * @author Administrator
 *
 */
public class Student {

/* 属性   成员变量 */
    public String name = null; // 姓名
    public String sex; // 性别
    public int age; // 年龄
    public String stuNo; // 学号
}

B. 局部变量：在方法中声明的变量，没有默认值，仅限于在一个方法中有用。

b. 局部变量组成部分：

— 访问修饰符

— 返回值

— 方法名称（必须是一个有效的标识符）

— 参数列表，在括号中出现

例如：

/* 方法 */

访问修饰符 返回值类型 方法名([参数列表]) {
         方法主体 -- 待实现的功能代码块
     }    
     */
    public void introduce() {
        System.out.println(this.toString());
        System.out.println("姓名：" + name + "\n性别：" +
                sex + "\n年龄：" + age +
               "\n学号：" + stuNo);
    }

5)   如何创建对象以及 访问对象的属性和方法？

例如：
import java.util.Scanner;
public class StudentTest {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        /* 创建学生对象 */
        Student stu = new Student();
        stu.introduce();
        // 为对象属性赋值
        // 如何调用对象的属性    对象名.属性名
        System.out.print("请输入姓名：");
        stu.name = input.next();
        System.out.print("请输入性别：");
        stu.sex = input.next();
        // 调用对象的方法，实现自我介绍
        // 对象名.方法名([实参列表]);
        System.out.println("********************");
        stu.introduce();
    }
}

7）  包（关键字：package）：包声明必须是源代码文件中除注释以外的第一条语句。

例如：

package com.lovo;

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student("0051", "王菲", 24);
        Student stu = new Student();
        student.display();
}

A. 用途：

a. 提供了一个组织类的机制。同时可以防止类命名冲突。

b. 为包中的类提供了一个命名空间。

B. 使用import关键字导入其它包中的类：

a. 使用类的全名。例如：pay.Employee;

b. 使用关键字import以及通配符（*）导入包。例如：import pay.*;

c. 使用关键字import导入类本身。例如：import pay.Employee;

1：继承的定义：

Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

2：关键字： extends ：继承

3：格式形式： public class A extends B {}  A:代表子类   B:代表父类
4：子类可继承父类的public，protected成员。

5：java中的继承是单继承的，具有单根性，传递性。所以一个类就只有一个父类。

6：方法重写： （子类对父类方法的重写）

其规则：

1：子类的返回值类型，方法名，参数列表必须和父类的相同；

2：访问修饰符必须大于父类修饰符的范围；

3：子类重写的异常不能抛出的比父类多。

与之区别的   方法重载
 规则：在一个类中有两个及以上的方法名相同，参数列表不同的。

7：super 关键字：父类 超类

8：final 关键字

1：final类：没有子类，不能被继承

2：final方法：不能被重写

3：final常量：常量值不能被修改

9：继承的优点：

1: 代码的重用性

2：父类的方法和属性可以用于子类

3：设计应用程序变得简单

4：子类可继承父类的属性和方法

Java基本特征[封装，继承，多态，抽象]
Java三大特性[封装，继承，多态]

封装

封装是使类中的成员变量都是private，并提供public方法访问这些变量的技术

实现封装：

1）、修改属性的可见性来限制对属性的访问。

2）、为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。

3）、在赋值和取值方法中，加入对属性的存取的限制。

用get方法访问成员变量，用set方法获取成员变量。

例如：

//员工类

public class Employee{

private String name;//名字

private String gender;//性别

......

}

//set方法获取名字

public void setName(String name){

　　this.name=name;

}

//get方法访问名字

public String getName(){

return this.name;

}

封装的好处：

通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。

由于取值方法和赋值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强。

继承
1：extends 关键字
public class Employee {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
... }
public class Manager extends Employee {
String department;
Employee[] subordinates;
... }
在这样的定义中，Manager 类被定义，具有 Employee 所拥有的所有变量及方法。所有 这些变量和方法都是从父类的定义中继承来的。
2：初始化子类必先初始化父类
在 Java 编程语言中，对象的初始化是非常结构化的，这样做是为了保证安全。在前面 的模块中，看到了当一个特定对象被创建时发生了什么。由于继承性，对象被完成，而且下 述行为按顺序发生：
（1）存储空间被分配并初始化到 0 值
（2）进行显式初始化
（3）调用构造方法

3.单继承性：

当一个类从一个唯一的类继承时，被称做单继承性。单继承性使代码更可靠。 接口提供多继承性的好处，而且没有（多继承的）缺点。 Java 编程语言允许一个类仅能继承一个其它类，即一个类只能有一个父类。这个限制 被称做单继承性

4：构造方法不能被继承

尽管一个子类从父类继承所有的方法和变量，但 它不继承构造方法，掌握这一点很重要。 一个类能得到构造方法，只有两个办法。或者写构造方法，或者根本没有写构造方法， 类有一个默认的构造方法。

5：关键字 super

关键字 super 可被用来引用该类的父类，它被用来引用父类的成员变量或方法

super 关键字的功能：

（1）：点取父类中被子类隐藏了的数据成员

（2）：点取已经覆盖了的方法

（3）：作为方法名表示父类构造方法

例如： public class Employee {

　　　　　　private String name;

　　　　　　 private int salary;

　　　　 public String getDetails() {

　　　　return "Name: " + name + "\nSalary: " + salary; }

　　}

　　 public class Manager extends Employee {

　　　　　　private String department;
　　　　public String getDetails() {

　　　　 return super.getDetails() + // 调用父类的方法 "\nDepartment: " + department; }

　　}
6：调用父类构造方法 在许多情况下，使用默认构造方法来对父类对象进行初始化。
 当然也可以使用 super 来显示调用父类的构造方法。
public class Employee {

　　 String name;

　　 public Employee(String n) {

　　this.name = n;

}

}
public class Manager extends Employee {

　　 String department;

　　 public Manager(String s, String d) {

　　 super(s);

　　 department = d;

}

}

注意：无论是 super 还是 this，都必须放在构造方法的第一行

多态

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。

多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

多态的好处：

1.可替换性（substitutability）。多态对已存在代码具有可替换性。

2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

instanceof

运算符功能：用来判断某个实例变量是否属于某种类的类型。
一旦确定了 变量所引用的对象的类型后，可以将对象恢复给对应的子类变量，以获取对象的完整功能。

例如：

public class Employee；

public class Manager extends Employee；

public class Contractor extends Employee ；

public void method(Employee e) {

if (e instanceof Manager) {

//如果雇员是经理，可以做的事情写在这里

}else if (e instanceof Contractor) {

//如果雇员是普通的职员，可以做的事情写在这里

}else { //说明是临时雇员，可以做的事情写在这里

}

}

两种类型转换

1.向上类型转换

将子类型转换为父类型。

对于向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名。

2.向下类型转换

将父类型转换为子类型。

对于向下的类型转换，必须要显式指定，即必须要使用强制类型转换。