JAVA读书笔记：面向对象

1.编程思想

编程思想的种类

        面向过程编程（procedure oriented Programming，POP），面向对象编程（object oriented programming，OOP)，函数式编程（functional programming，FP)

典型代表

        POP：C、Fortran、Basic。

        OOP：Java、C++、Python、PHP、Smalltalk、Eiffel。

        FP：lisp、haskell、scala。

Java是面向对象编程语言

        面向对象编程（object oriented programming，OOP）是软件开发的一种新的方法，使用这种方法开发的软件具有易维护、可重用和可扩展等特征。

        OO技术主要包括三个领域：面向对象分析（object oriented analysis，OOA）、面向对象设计（object oriented design，OOD）和面向对象编程（object oriented programming，OOP）。

2.类与对象

2.1 面向对象概述

基本概念

        1.对象：现实世界中的一个实体。

        其特征：有一个状态用来描述它的某些特征。有一组操作，每个操作决定对象的一种功能或行为。

        2.类：具有相似特征和行为的对象的集合。

        类与对象的关系：属于某个类的一个具体的对象称为该类的一个实例（instance）。

        类与实例的关系：抽象与具体的关系。类是多个实例的综合抽象，实例是某个类的个体实物。

基本特征

        面向对象程序设计的三大特征是封装性、继承性和多态性。

2.2 类的定义

类声明的格式:

[public][abstract|final] class ClassName [extends SuperClass][implements InterfaceNameList]{

        //1.成员变量声明

        //2.构造方法的定义

        //3.成员方法的定义

}

public:使类可被任何包中的类使用，缺省，则只能被同一包中的其他类使用。

abstract:使类成为抽象类。

final:使类成为最终类。

class:类的关键字。

ClassName:类的名称。

extends:指向继承某个父类的关键字。

SuperClass:该类要继承某个父类，它的名称。

implements:类实现接口的关键字。

InterfaceNameList:被实现的接口列表，用逗号分隔。

成员变量的声明格式:

[public|protected|private][static][final] type variableName[=value];

public:使变量可以被任何方法访问。

protected:使变量可以被同一个包中的类或子类访问。

private:使变量只能被同一个类的方法访问。

缺省访问修饰符:该变量只能被同一个包中的类访问。

static:该变量为静态变量，缺省，为实例变量。

final:该变量为最终变量，也称为标识符常量，一旦为其赋值，就不能再改变了。

type:该变量的类型。

variableName:变量名称。

value:变量值。

构造方法的定义格式:

[public|protected|private] ClassName([paramList]){

        //方法体

}

构造方法的访问修饰符用来决定哪些类可以使用构造方法创建对象，其含义与一般方法的相同。

ClassName:构造方法名，必须与类名相同。

paramList:参数列表，构造方法可以带有参数。

public ClassName(){

}//默认构造方法(无参构造方法)，不带参数，方法体为空

成员方法的定义格式:

[public|protected|private][static][final|abstract] returnType methodName ([paramList]){

         //方法体

}

public:使方法可以在任何类中调用。

protected:使方法可以在同一个类、同一个包中的类以及子类中被调用。

private:使方法只能在同一个类中被调用。

缺省访问修饰符:可以被同一个类的方法访问和同一个包中的类访问。

static:该方法为静态方法，缺省为实例方法。

final:该方法为最终方法，它不能被覆盖。

abstract:该方法为抽象方法。

3.面向对象的继承性

概念

        继承的基本思想是可以从已有的类派生出新类。在类的层次结构中，被继承的类称为父类(parent class)/超类(super class)，继承得到的类称为子类(sub class)/派生类(derived class)。子类继承父类的状态和行为，同时也可以具有自己的特征。

类继承的实现

使用extends关键字，格式如下:

[public] class SubClass extends SuperClass{

        //类体定义

}

程序示例:

Person.java

package com.demo;

     public class Person{

     public String name;

     public int age;

     public Person(){

     }

     public Person(String name,int age){

                 this.name＝name;

                 this.age=age;

     }

     public void sayHello(){

                System.out.println("My name is "+name);

     }

}

 这里定义了两个类，分别是Person类和Employee类。Employee类使用关键字extends继承或扩展了Person类，Employee为子类，Person为父类。

关于类继承的几点说明:

        1.子类继承父类中非private的成员变量和成员方法，若父类中定义了公共的访问方法和修改方法，子类可以通过这些方法来访问或修改private的成员变量和方法。

        2.定义类时若省略extends关键字，则所定义的类为java.lang.Object类的直接子类。

        3.Java仅支持单重继承，即一个类至多只有一个直接父类。可以通过接口实现其他语言中的多重继承。

方法覆盖

        子类定义与父类中的名字、参数列表、返回值类型都相同的方法，这时子类的方法就叫作覆盖（overriding）或重写了父类的方法。子类重写父类的方法，应在要重写的方法前添加@Override注解，使用注解可以避免错误。

        例如在子类Employee中重写父类Person的方法sayHello（），如下所示：

        @Override

         public void sayHello(){

                System.out.println("Hello ,I am "+name+"."+"I am "+age+".");

     }

方法覆盖两点注意：

        1.private方法不能覆盖。

        2.static方法不能被覆盖，可以继承父类的static方法。

super关键字

        子类可以使用super关键字，来引用当前对象的父类对象，可用于如下三种情况：

        1.子类调用父类被覆盖的方法，格式为：

        super.methodName([paramlist])

        2.子类调用父类的构造方法，格式为：

        super([paramlist])

        3.子类访问父类中被隐藏的成员变量，格式为：

        super.variableName

        这里，methodName表示要调用的父类中被覆盖的方法名；paramlist表示方法传递的参数；variableName表示要访问的父类中被隐藏的变量名。

调用父类的构造方法

        子类不能继承父类的构造方法，所以要创建子类对象，需要使用默认构造方法或为子类定义构造方法。Java语言规定，创建子类对象时，必须先创建该类的所有父类对象。因此，在编写子类的构造方法时，必须保证它能够调用父类的构造方法。

        1.子类构造方法调用父类构造方法的两种方式：

        1）使用super来调用父类的构造方法

        super([paramlist]);

        2）调用父类的默认构造方法

        若子类构造方法没有使用super调用父类构造方法，编译器将自动在第一句加上super()父类无参的构造方法。

        子类构造方法可以使用this调用本类的其他构造方法。需要注意的是this和super语句必须是构造方法中的第一条语句，并且最多只有一条这样的语句，不能既调用this，又调用super。

        2.构造方法的调用过程

        在任何情况下，创建一个类的实例时，将会沿着继承链调用所有父类的构造方法，这叫作构造方法链。系统首先调用所有父类的构造方法，包括所有类的根类Object类的构造方法。

4.面向对象的封装性

概念

        在Java语言中，对象就是一组变量和方法的封装体。封装性实现了模块化和信息隐藏，有利于程序的可移植性和对象的管理。

        对象的封装是通过下面两种方式实现的：

        （1）通过包实现封装性。在定义类时使用package语句指定类属于那个包。包是Java语言最大的封装单位，定义了程序对类的访问权限。

        （2）通过类或类的成员访问权限实现封装性。

                类的访问权限通过修饰符public实现，public类可以被任何其他类使用，缺省访问修饰符的类仅能被同一包中的类使用。

                类成员的访问修饰符共有4个，分别是private、缺省的、protected和public，各自访问权限如下图所示：

      

5.面向对象的多态性

概念

        多态（polymorphism）就是多种形式，是指Java程序中一个类或多个类中可以定义多个同名方法，这多个同名方法完成的操作不同，这就是多态。多态性是指在运行时系统判断应该执行哪个方法的代码的能力。

        Java语言支持两种类型的多态：

        （1）静态多态：也叫编译时多态，是通过方法重载实现的。

                对重载的方法，Java运行时系统根据传递给方法的参数个数和类型确定调用哪个方法。

        （2）动态多态：也叫运行时多态，是通过方法覆盖实现的。

                对覆盖的方法，运行时系统根据实际类型决定调用哪个方法。对子类的一个实例，如果子类覆盖了父类的方法，运行时系统调用子类的方法，如果子类继承了父类的方法，则运行时系统调用父类的方法。

对象转换

        子类是它父类的特殊化，每个子类的实例也都是它父类的实例，但反过来不成立。因此子类对象和父类对象在一定条件下也可以相互转换，这种类型转换一般称为对象转换或造型(casting)。

        对象转换也有自动转换和强制转换之分。因为子类的实例总是它父类的实例，所以总是可以把一个子类的实例转换成一个父类的变量，子类对象可以自动转换为父类对象，这种转换称为向上转换(up casting)。当把父类实例转换为子类变量时，必须使用强制类型转换，强制类型转换需要使用转换运算符“()”。