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

类、对象和包

1) 面向对象编程(Object Oriented Programming ,简称 OOP):20世纪70年代以后开始流行。

2) 结构化编程与面向对象编程的区别:

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

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

3) 对象和类

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

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

C. 两者关系:类是对象的抽象(描述),对象是类的实例。

4) 成员变量和局部变量

A. 成员变量:在类中声明的变量,有默认值,可以用在一个类的所有地方。
一个对象的成员变量的初始值  成员变量的数据类型       初始值
         Java—继承、封装、抽象、多态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)   如何创建对象以及 访问对象的属性和方法?

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

例如:
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();
    }
}

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

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; }

  }
Java—继承、封装、抽象、多态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.向下类型转换

将父类型转换为子类型。

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

上一篇:java继承,多态


下一篇:java面向对象(封装-继承-多态)