面向对象、类与对象、成员与局部变量、封装、private、构造函数、this、static、extends、super、final、abstract、interface、多态、内部类、异常【5】

本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/

本文版权归作者和博客园共有，未经作者同意必须保留此段声明，
且在文章页面明显位置给出原文连接 ，否则保留追究法律责任的权利。

面向对象概念

面向对象是相对面向过程而言

面向对象和面向过程都是一种思想

面向过程

　　•强调的是功能行为

面向对象

　　•将功能封装进对象，强调具备了功能的对象。

面向对象是基于面向过程的。

面向过程

  　　在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口本身的定义没有任何关系，

如HideWindow，MoveWindow，MinimizeWindow，这些函数都需要接受一个代表要被操作的窗口参数 ，

是一种谓语与宾语的关系 。

面向对象

    　 定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，还要指定该窗口可能具有的动作 ，

如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的 ，

这是一种主语与谓语的关系。

面向过程的思想和面向对象的思想

　　面向对象和面向过程的思想有着本质上的区别, 作为面向对象的思维来说，当你拿到一个问题时，

你分析这个问题不再是第一步先做什么，

第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，

然后再分析这些类和对象应该具有哪些属性和

方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。

      面向对象有一个非常重要的设计思维：合适的方法应该出现在合适的类里面

面向对象的设计思想

　　面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。

　　面向对象更加强调运用人类在日常生活的逻辑思维中经常采用的思想方法与原则，如抽象、分类，继承、聚合、多态等。

　　人在思考的时候，首先眼睛里看到的是一个一个的对象。

是一种符合人们思考习惯的思想

可以将复杂的事情简单化

将程序员从执行者转换成了指挥者

完成需求时：

　　• 先要去找具有所需的功能的对象来用。

　　• 如果该对象不存在，那么创建一个具有所需功能的对象。

　　• 这样简化开发并提高复用。

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程：其实就是在管理和维护对象之间的关系。

面向对象的特征：

　　•封装(encapsulation)

　　•继承(inheritance)

　　•多态(polymorphism)

面向对象还支持如下几个功能：

     1）对象是面向对象方法中最基本的概念，它的基本特点是：标识唯一性、分类性、多态性、封装性、模块独立性好。

     2）类是具有共同属性、共同方法的一类事物。类是对象的抽象；对象则是类的实例。

　　　而类是整个软件系统最小的程序单元，类的封装性将各种信息细节隐藏起来，并通过公用方法来暴露该类对所提供的功能，

　　　从而提高了类的内聚性，降低了对象之间的耦合性。

     3）对象间的这种相互合作需要一个机制协助进行，这样的机制称为“消息”。消息是一个实例与另一个实例之间相互通信的机制。

     4）在面向对象方法中，类之间共享属性和操作的机制称为继承。继承具有传递性。

　　　继承可分为单继承（一个继承只允许有一个直接父类，即类等级为树形结构）与多继承（一个类允许有多个直接父类），

　　　但Java不支持多继承。

在Java语言中除了8个基本数据类型值之外，一切都是对象，而对象就是面向对象程序设计的中心。

对象具有状态，一个对象用数据值来描述它的状态。Java通过对对象定义Field（以前常被称为属性，现在也称字段）来描述对象的状态；

对象还有操作，这些操作可以改变对象的状态，

对象的操作也被称为对象的行为，Java通过为对象定义方法来描述对象的行为。

       对象是Java程序的核心，所以在Java里的对象具有唯一性，每个对象都有一个标识来引用它，

如果某个对象失去了标识，这个对象将变成垃圾，只能等着系统垃圾回收机制来回收它。Java语言不允许直接访问对象，

而是通过对对象的引用来操作对象。

在Java语言使用class关键字定义类，定义类时可使用Field来描述该类对象的数据，可使用方法来描述该类对象的行为特征。

Java语言使用extends关键字来表示继承关系。

Java使用new关键字来创建指定类的对象，每个类可以创建任意多个对象，多个对象的Field值可以不同。

使用计算机语言就是不断的在描述现实生活中的事物。

java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

对象即是该类事物实实在在存在的个体。

类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。 

　　　　类与对象的关系如图

可以理解为：

　　•类就是图纸

　　•汽车就是堆内存中的对象

对于同一类事物可以抽取它们的共性的内容，定义在类中。

如生活中的汽车，每一台车都有轮胎数和颜色。

那么在通过java描述汽车这类事物时，就可以将这两个共性属性作为类中的属性进行定义。

通过该类建立的每一个汽车实体都具有该属性，并可以有对象特有的属性值。

生活中描述事物无非就是描述事物的属性和行为。

　　•如：人有身高，体重等属性，有说话，打球等行为。

Java中用类class来描述事物也是如此

　　•属性：对应类中的成员变量。

　　•行为：对应类中的成员函数。

定义类其实在定义类中的成员(成员变量和成员函数)。

每一个JAVA里面的class（类）都对应了我们现实生活中某一类事物的一个抽象。

成员变量：

　　•成员变量定义在类中，在整个类中都可以被访问。

　　•成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

　　•成员变量有默认初始化值。

局部变量：

　　•局部变量只定义在局部范围内，如：函数内，语句内等。

　　•局部变量存在于栈内存中。

　　•作用的范围结束，变量空间会自动释放。

　　•局部变量没有默认初始化值。

方法体中局部变量若与成员变量同名，局部变量将屏蔽成员变量。

class Variable {

    int x = 0, y = 0, z = 0; // 类的成员变量

    void init(int x, int y) {
        this.x = x;
        this.y = y;
        int z = 5; // 局部变量
        System.out.println("** in init**");
        System.out.println("x = " + x + "y = " + y + "z = " + z);
    }
}

public class VariableTest {
    public static void main(String args[]) {
        Variable v = new Variable();
        System.out.println("** before init **");
        System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
        v.init(20, 30);
        System.out.println("** after init **");
        System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
    }
}

class Car//对Car这类事物进行描述
{
    String color = "red";
    int num = 4;
    void show()
    {
        System.out.println("color="+color+"..num="+num);
    }
}

1 class CarDemo
2 {
3     public static void main(String[] args)
4     {
5         Car c = new Car();//建立对象
6         c.color = "black";//对对象的属性进行修改
7         c.show();//使用对象的功能。
8     }
9 }

对象内存结构

Car c1 = new Car();　　c1.color="blue";

Car c2 = new Car();

只要是用new操作符定义的实体就在会堆内存中开辟一个新的空间。

并每一个对象中都有一份属于自己的属性。

通过 对象.对象成员 的方式操作对象中的成员，

对其中一个对象的成员进行了修改。和另一个对象没有关系。

匿名对象是对象的简化形式

匿名对象两种使用情况

　　•当对对象方法仅进行一次调用时

　　•匿名对象可以作为实际参数进行传递

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

　　•将变化隔离。

　　•便于使用。

　　•提高重用性。

　　•提高安全性。

封装原则：

　　•将不需要对外提供的内容都隐藏起来。

　　•把属性都隐藏，提供公共方法对其访问。

　　
　　　要求使对象之外的部分不能随意存取对象的内部数据，从而有效避免了错误对它的“交叉感染”，使软件错误能局部化，降低排错难度

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，

即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装隐藏了类的内部实现机制，

从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。

private关键字：

　　•是一个权限修饰符。

　　•用于修饰成员(成员变量和成员函数)

　　•被私有化的成员只在本类中有效。

常用之一：

　　•将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性。

特点：

　　1.函数名与类名相同

　　2.不用定义返回值类型

　　3.没有具体的返回值。

作用：

　　给对象进行初始化。

注意：

　　1.默认构造函数的特点。

　　2.多个构造函数是以重载的形式存在的。

特点：this代表其所在函数所属对象的引用。

换言之：this代本类对象的引用。

什么时候使用this关键字呢？

当在函数内需要用到调用该函数的对象时，就用this。

 static(静态)关键字

static关键字：

　　•用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

　　随着类的加载而加载

　　优先于对象存在

　　被所有对象所共享

　　可以直接被类名调用

使用注意

　　静态方法只能访问静态成员

　　静态方法中不可以写this，super关键字

　　主函数是静态的

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可。

多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。

　　•class SubDemo extends Demo{}

继承的出现提高了代码的复用性。

继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：子类不可以具备父类中私有的内容。

父类怎么来的？共性不断向上抽取而来的。

继承关系封装了这样一种逻辑：“XX是一种XX”，只要能说通，就可以考虑用继承关系来封装它。

Java只支持单继承，不支持多继承。

　　•一个类只能有一个父类，不可以有多个父类。

　　•class SubDemo extends Demo{} //ok

　　•class SubDemo extends Demo1,Demo2...//error

Java支持多层继承(继承体系)

　　•class A{}

　　•class B extends A{}

　　•class C extends B{}

定义继承需要注意：

　　•不要仅为了获取其他类中某个功能而去继承

　　•类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

注意：因为多继承容易出现问题。

两个父类中有相同的方法。子类到底要执行哪一个是不确定的。

所以java不支持多继承，但将这种机制换了另一个种安全的方式来体现，多实现。

多次继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。

对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），

而原始类称为新类的基类（父类）。

派生类可以从它的基类那里

继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

因此可以说，继承是为了重用父类代码，同时为实现多态性作准备。

super和this的用法相像

this代表本类对象的引用

super代表父类的内存空间的标识。

当子父类出现同名成员时，可以用super进行区分

子类要调用父类构造函数时，可以使用super语句。

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

父类中的私有方法不可以被覆盖。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：

　　•覆盖时，子类方法权限一定要大于等于父类方法权限

　　•静态只能覆盖静态。

覆盖的应用：

　　•当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，

这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类中所有的构造函数默认都会访问父类中空参数的构造函数

因为每一个构造函数的第一行都有一条默认的语句super();

子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量。只能被赋值一次。

内部类只能访问被final修饰的局部变量。

抽象定义：

　　•抽象就是从多个事物中将共性的，本质的内容抽取出来。

　　•例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象类：

　　•Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：

　　•多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，

那么只有功能声明，没有功能主体的方法称为抽象方法。

　　•例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

抽象——就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。

(就是把现实世界中的某一类东西，提取出来，用程序代码表示，抽象出来一般叫做类或者接口。)抽象并不打算了解全部问题，

而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是数据抽象，二是过程抽象。

数据抽象——就是用代码的形式表示现时世界中一类事物的特性，就是针对对象的属性。

比如建立一个鸟这样的类，鸟都有以下属性：一对翅膀、两只脚、羽毛等。抽象出来的类都是鸟的属性，或者成员变量。

过程抽象——就是用代码形式表示现实世界中事物的一系列行为，就是针对对象的行为特征（方法）。

比如鸟会飞、会叫等。抽象出来的类一般都是鸟的方法。

抽象类和抽象方法必须用abstract关键字来修饰。

抽象方法只有方法声明，没有方法体，定义在抽象类中。

　　•格式：修饰符 abstract 返回值类型   函数名(参数列表) ;

抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：

　　•抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。

　　•而且抽象类即使创建了对象，调用抽象方法也没有意义。

抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

　　　　　  用abstract关键字修饰类:抽象类

　　　　用abstract关键字修饰方法：抽象方法

　　　　抽象类必须被继承，抽象方法必须被重写

　　　　抽象方法只需声明，无需实现

　　　　抽象类不能被实例化，抽象类不一定要包含抽象方法

　　　　若类中包含抽象方法，给类必须被定义为抽象类

格式：

    interface {}

接口中的成员修饰符是固定的。

　　•成员常量：public static final

　　•成员函数：public abstract

　　•发现接口中的成员都是public的。

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口是对外暴露的规则。

接口是程序的功能扩展。

接口的出现降低耦合性。

接口可以用来多实现。

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

接口是抽象类的一种，只包含常量和方法的定义，没有变量和方法的实现，且其方法都是抽象方法。

　　　　用处体现在：

　　　　　　通过接口，实现不相关类的相同行为

　　　　　　通过接口，指明多个类需要实现的方法

　　　　　　通过接口，了解对象的交互界面，无需了解对象所对应的类

　　　　接口的实现：

　　　　　　在类的声明中用implements子句来表示一个类使用某个接口

　　　　　　类体中可以使用接口中定义的常量，必须实现接口中定义的所有方法

　　　　　　一个类可以实现多个接口，在implements中用逗号隔开

　　　　接口类型的使用：

　　　　　　接口作为一种引用类型来使用

　　　　　　任何实现该接口的类的实例，都可以存储在该接口类型的变量中，通过这些实例，访问该类接口中的方法。

定义：某一类事物的多种存在形态。

　　例：动物中猫，狗。

　　猫这个对象对应的类型是猫类型

　　　　•猫 x = new 猫();

　　同时猫也是动物中的一种，也可以把猫称为动物。

　　　　•动物  y = new 猫();

　　　　•动物是猫和狗具体事物中抽取出来的父类型。

　　　　父类型引用指向了子类对象。

class A {
    void callme() {
        System.out.println("Inside A‘s callme()) method");
    }
}

class B extends A {
    void callme() {
        System.out.println("Inside B‘s callme() method");
    }
}

public class Dispatch {
    public static void main(String args[]) {
        A a = new B(); // 引用子类的实例
        a.callme();
    }
}

　　父类或者接口的引用指向或者接收自己的子类对象。

好处和作用：

　　多态的存在提高了程序的扩展性和后期可维护性

前提：

　　•需要存在继承或者实现关系

　　•要有覆盖操作

子类继承父类后，同一个方法有不同的表现

　　体现在两个方面：方法重载实现的静态多态性（编译时多态），方法重写实现的动态多态性（运行时多态）

　   重写方法的调用原则：子类重写父类的方法，调用子类方法；反之，调用父类的方法

成员函数：

　　•编译时：要查看引用变量所属的类中是否有所调用的成员。

　　•在运行时：要查看对象所属的类中是否有所调用的成员。

成员变量：

　　•只看引用变量所属的类。

多态指是的子类对象可以直接赋给父类变量，但运行时依然表现出子类的行为特征

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。

多态性语言具有灵活、抽象、行为共享、代码共享

的优势，很好的解决了应用程序函数同名问题。总的来说，方法的重写、重载与动态链接构成多态性。

Java引入多态的概念原因之一就是弥补

类的单继承带来的功能不足。（为规避C++中多继承造成的复杂继承问题，java采用单继承。）

动态链接——对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态链接。

注意：继承与重载：一是子类与父类的关系，二是重载方法的调用问题。

子类对象可以直接当成父类对象使用，但反过来就不可以。举例来说，人是父类，学生是人的子类，

所以学生对象一定具备人对象的属性，但是人对象就未必具有学生对象的特性。

所以学生对象可以当做人对象来使用，但是人对象就不能当做学生对象使用。

注意当把子类对象当成父类对象使用时，子类对象将失去所有的子类特性，

只保留与父类同名的属性和方法（同名方法不仅是函数名相同，而且参数类型也要一样，否则不予

保留）。此时可以对父类方法进行重写。

一个类中如果定义了重载的方法，则系统在调用方法时，会根据参数的类型自动选择调用合适的方法。

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

访问特点：

　　•内部类可以直接访问外部类中的成员，包括私有成员。

　　•而外部类要访问内部类中的成员必须要建立内部类的对象。

内部类的位置

内部类定义在成员位置上

　　•可以被private static成员修饰符修饰。

　　•被static修饰的内部类只能访问外部类中的静态成员。

内部类定义在局部位置上

　　•也可以直接访问外部类中的成员。

　　•同时可以访问所在局部中的局部变量，但必须是被final修饰的。

就是内部类的简化写法。

前提：

　　•内部类可以继承或实现一个外部类或者接口。

格式为：

　　•new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

简单理解：

　　•就是建立一个带内容的外部类或者接口的子类匿名对象。

什么时候使用匿名内部类呢？

通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。

增强阅读性。

匿名内部类示例：

abstract class A {

    abstract public void fun1();
}

class Outer {

    public static void main(String[] args) {

        new Outer().callInner(new A() {

            public void fun1() {

                System.out.println("implement for fun1");
            }
        });
    }

    public void callInner(A a) {
        a.fun1();
    }
}

异常的体系

　　•Throwable

　　　　•Error

　　　　　　•通常出现重大问题如：运行的类不存在或者内存溢出等。

　　　　　　•不编写针对代码对其处理

　　　　•Exception

　　　　　　•在运行时运行出现的一种情况，可以通过try catch finally

lException和Error的子类名都是以父类名作为后缀。

Java在设计异常体系时，将容易出现的情况都封装成了对象。

getMessage()

　　•获取异常信息，返回字符串。

toString()

　　•获取异常类名和异常信息，返回字符串。

printStackTrace()

　　•获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

printStackTrace(PrintStream s)

　　•通常用该方法将异常内容保存在日志文件中，以便查阅。 

throws用于标识函数暴露出的异常。

throw用于抛出异常对象。

throws与throw的区别：

　　•thorws用在函数上，后面跟异常类名。

　　•throw用在函数内，后面跟异常对象。

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在函数上标识。

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

try

{

  需要检测的代码；

}

catch(异常类  变量)

{

  异常处理代码；

}

finally

{

  一定会执行的代码； 

}

Finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)。

处理过程：

Try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。

Finally里通常用来关闭资源。比如：数据库资源，IO资源等。

需要注意：try是一个独立的代码块，在其中定义的变量只在该变量块中有效。

如果在try以外继续使用，需要在try建立引用。在try对其进行初始化。IO，Socket就会遇到。

自定义类继承Exception或者其子类。

通过构造函数定义异常信息。

例：

Class DemoException extends Exception

{

  DemoException(String message)

  {

  super(message);

  }

}

通过throw将自定义异常抛出。

RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。

一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。

如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。

介绍异常在分层设计时的层内封装。

对类文件进行分类管理。

给类提供多层命名空间。

写在程序文件的第一行。

类名的全称的是  包名.类名。

包也是一种封装形式。

classpath

给JVM提供的一个环境变量。

指定类或者包所在的路径。

包之间的访问

被访问的包中的类权限必须是public的。

类中的成员权限：public或者protected

protected是为其他包中的子类提供的一种权限

四种权限

import *

一个程序文件中只有一个package，可以有多个import。

用来导包中的类，不导入包中的包。

Java的压缩包

　　•方便项目的携带。

　　•方便于使用，只要在classpath设置jar路径即可。

　　•数据库驱动，SSH框架等都是以jar包体现的。

通过jar.exe工具对jar的操作。

　　•创建jar包

　　　　•jar  -cvf  mypack.jar  packa packb

　　•查看jar包

　　　　•jar  -tvf  mypack.jar   [>定向文件]

　　•解压缩

　　　　•jar  -xvf  mypack.jar

　　•自定义jar包的清单文件

　　　　•jar –cvfm  mypack.jar  mf.txt  packa packb

c：创建压缩文档。

f：制定存档名称。

v：显示详细信息。

m：加入自定义清单信息。

通常应用与Java制作的图形界面程序。在清单文件中其中定一个Main-Class:空格 带有主函数的类名回车

在设置一下jar文件的打开方式通过javaw –jar就可以双击执行了。