面向对象、类与对象、成员与局部变量、封装、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);
     }
 }

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

CarDemo

对象内存结构

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

Car c2 = new Car();

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

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

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

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

---

匿名对象

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

 

匿名对象两种使用情况

 

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

 

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

 

---

封装(Encapsulation)

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

好处：

　　•将变化隔离。

　　•便于使用。

　　•提高重用性。

　　•提高安全性。

封装原则：

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

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

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

使软件错误能局部化，降低排错难度

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

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

封装隐藏了类的内部实现机制，

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

---

private(私有)关键字

private关键字：

　　•是一个权限修饰符。

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

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

常用之一：

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

---

构造函数

特点：

　　1.函数名与类名相同

 

　　2.不用定义返回值类型

 

　　3.没有具体的返回值。

作用：

　　给对象进行初始化。

注意：

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

 

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

---

this关键字

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

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

 

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

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

---

用类名定义一个变量的时候，定义的应该只是一个引用，外面可以通过这个引用来访问这个类里面的属性和方法

 this它可以在类里面来引用这个类的属性和方法。先来个简单的例子：

public class Test {
    String name = "Mick";
 
    public void print(String name) {
        System.out.println("类中的属性 name=" + this.name);//成员name
        System.out.println("局部传参的属性=" + name);//局部name
    }
 
    public static void main(String[] args) {
        Test tt = new Test();
        tt.print("Orson");
    }
}

Test

打印结果：

---

关于返回类自身的引用，《Thinking in Java》有个很经典的例子，

通过this 这个关键字返回自身这个对象然后在一条语句里面实现多次的操作

public class ThisDemo {
    int number;
 
    ThisDemo increment() {
        number++;
        return this;
    }
 
    private void print() {
        System.out.println("number=" + number);
    }
 
    public static void main(String[] args) {
        ThisDemo tt = new ThisDemo();
        tt.increment().increment().increment().print();
    }
}

打印结果：

---

public class ThisDemo {
    String name;// 姓名
    int age;// 年龄
 
    public ThisDemo() {
        this.age = 21;
    }
 
    public ThisDemo(String name, int age) {
        this();
        this.name = "Mick";
    }
 
    private void print() {
        System.out.println("最终名字=" + this.name);
        System.out.println("最终的年龄=" + this.age);
    }
 
    public static void main(String[] args) {
        ThisDemo tt = new ThisDemo("", 0); // 随便传进去的参数
        tt.print();
    }
}

ThisDemo

打印结果：

---

 

public class ThisDemo {
    private int i = 0;
 
    // 第一个构造器：有一个int型形参
    ThisDemo(int i) {
        this.i = i + 1;// 此时this表示引用成员变量ｉ，而非函数参数ｉ
        System.out.println("第一个int构造函数形参 i的值为:" + i + "        this.i的值为:" + this.i);
        System.out.println("int形参i-1的值为:" + (i - 1) + "            this.i+1的值为:" + (this.i + 1));
        // 从两个输出结果充分证明了i和this.i是不一样的！
    }
 
    // 第二个构造器：有一个String型形参
    ThisDemo(String s) {
        System.out.println("String 构造函数:  " + s);
    }
 
    // 第三个构造器：有一个int型形参和一个String型形参
    ThisDemo(int i, String s) {
        this(s);// this调用第二个构造器
        //this(i);
        /*
         * 此处不能用，因为其他任何方法都不能调用构造器，只有构造方法能调用他。
         * 但是必须注意：就算是构造方法调用构造器，也必须为其第一行，构造方法也只能调 用一个且仅一次构造器！
         */
        this.i = i++;// this以引用该类的成员变量
        System.out.println("Int 形参:  " + i + "\t    "
                + "String 形参:  " + s);
    }
 
    public ThisDemo increment() {
        this.i++;
        return this;// 返回的是当前的对象，该对象属于（ThisDemo）
    }
 
    public static void main(String[] args) {
        ThisDemo tt0 = new ThisDemo(10);
        ThisDemo tt1 = new ThisDemo("ok");
        ThisDemo tt2 = new ThisDemo(20, "ok again!");
 
        System.out.println(tt0.increment().increment().increment().i);
        // tt0.increment()返回一个在tt0基础上ｉ++的ThisDemo对象，
        // 接着又返回在上面返回的对象基础上i++的ThisDemo对象！
    }
}

ThisDemo

 打印结果：

总结下：

１、表示对当前对象的引用！

２、表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！

　　其实这是第一种用法的特例，比较常用，所以拿出来强调一下。

３、用于在构造方法中引用满足指定参数类型的构造器（其实也就是构造方法）。

但是这里必须非常注意：只能引用一个构造方法且必须位于开始第一行！

还有就是注意：this不能用在static方法中！

---

 static(静态)关键字

static关键字：

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

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

　　随着类的加载而加载

　　优先于对象存在

　　被所有对象所共享

　　可以直接被类名调用

使用注意

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

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

　　主函数是静态的

---

　　　　　　　　　　　　　　　　　　　　　　　　　　static方法

“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。

而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：

　　方便在没有创建对象的情况下来进行调用（方法/变量）。

很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

　　static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，

因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，

在静态方法中不能访问类的非静态成员变量和非静态成员方法，

因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。

因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，

但是在非静态成员方法中是可以访问静态成员方法/变量的。

因此，如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。

我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。

因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。

　　另外记住，即使没有显示地声明为static，类的构造器实际上也是静态方法。

---

static 变量

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，

它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，

存在多个副本，各个对象拥有的副本互不影响。

　　static成员变量的初始化顺序按照定义的顺序进行初始化。

所以一般在需要实现以下两个功能时使用静态变量：

• 在对象之间共享值时
• 方便访问变量时

---

static代码块

static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。

static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，

会按照static块的顺序来执行每个static块，并且只会执行一次。

类中定义的静态代码块会优先于构造块先执行，而且不管有多少个对象，静态代码块只执行一次

　　为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:

import java.sql.Date;
 
class ThisDemo {
    private Date birthDate;//生日
 
    public ThisDemo(Date birthDate) {
        this.birthDate = birthDate;
    }
 
    boolean isBornBoomer() {//出生日期
        Date startDate = Date.valueOf("1946");
        Date endDate = Date.valueOf("1964");
        return birthDate.compareTo(startDate) >= 0
                && birthDate.compareTo(endDate) < 0;
    }
}

ThisDemo

isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，

都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：

import java.sql.Date;
 
class Person {
    private Date birthDate;
    private static Date startDate, endDate;
    static {
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }
 
    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }
 
    boolean isBornBoomer() {
        return birthDate.compareTo(startDate) >= 0
                && birthDate.compareTo(endDate) < 0;
    }
}

Person

 因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

虽然对于静态方法来说没有this，那么在非静态方法中能够通过this访问静态成员变量吗？

先看下面的一个例子，这段代码输出的结果是什么？

public class ThisDemo {
    static int value = 33;
 
    public static void main(String[] args) throws Exception {
        new ThisDemo().printValue();
    }
 
    private void printValue() {
        int value = 3;
        System.out.println(this.value);
    }
}

ThisDemo

打印结果：

这里面主要考察队this和static的理解。this代表什么？this代表当前对象，

那么通过new ThisDemo()来调用printValue的话，

当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的，

因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量，

根本不可能与this关联，所以输出结果是33。在这里永远要记住一点：

静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，

所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

static是不允许用来修饰局部变量, 这是Java语法的规定。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用

当然也可以在非静态成员方法中使用,但是不能在其他类中通过类名来直接引用，这一点很重要。

实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。

static前面加上其它访问权限关键字的效果也以此类推。

---

static和final一块用表示什么

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！

        对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

        对于方法，表示不可覆盖，并且可以通过类名直接访问。

       

        特别要注意一个问题：

 

        对于被static和final修饰过的实例常量，实例本身不能再改变了，

 

但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，

 

但可以修改容器中存放的对象，这一点在编程中用到很多。举例如下：

import java.util.ArrayList;
 
public class TestStaticFinal {
    private static final String strStaticFinalVar = "aaa";
    private static String strStaticVar = null;
    private final String strFinalVar = null;
    private static final int intStaticFinalVar = 0;
    private static final Integer integerStaticFinalVar = new Integer(8);
    private static final ArrayList<String> alStaticFinalVar = new ArrayList<String>();
 
    private void test() {
        System.out.println("-------------值处理前----------\r\n");
        System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
        System.out.println("strStaticVar=" + strStaticVar + "\r\n");
        System.out.println("strFinalVar=" + strFinalVar + "\r\n");
        System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
        System.out.println("integerStaticFinalVar=" + integerStaticFinalVar
                + "\r\n");
        System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
 
        // strStaticFinalVar="哈哈哈哈"; //错误，final表示终态,不可以改变变量本身.
        strStaticVar = "哈哈哈哈"; // 正确，static表示类变量,值可以改变.
        // strFinalVar="呵呵呵呵"; //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
        // intStaticFinalVar=2; //错误,
        // final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
        // integerStaticFinalVar=new Integer(8); //错误,
        // final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
        alStaticFinalVar.add("aaa"); // 正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
        alStaticFinalVar.add("bbb"); // 正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
 
        System.out.println("-------------值处理后----------\r\n");
        System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
        System.out.println("strStaticVar=" + strStaticVar + "\r\n");
        System.out.println("strFinalVar=" + strFinalVar + "\r\n");
        System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
        System.out.println("integerStaticFinalVar=" + integerStaticFinalVar
                + "\r\n");
        System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
    }
 
    public static void main(String args[]) {
        new TestStaticFinal().test();
    }
}

TestStaticFinal

打印结果：

-------------值处理前----------
 
strStaticFinalVar=aaa
 
strStaticVar=null
 
strFinalVar=null
 
intStaticFinalVar=0
 
integerStaticFinalVar=8
 
alStaticFinalVar=[]
 
-------------值处理后----------
 
strStaticFinalVar=aaa
 
strStaticVar=哈哈哈哈
 
strFinalVar=null
 
intStaticFinalVar=0
 
integerStaticFinalVar=8
 
alStaticFinalVar=[aaa, bbb]

看了上面这个例子，就清楚很多了，但必须明白：

通过static final修饰的容器类型变量中所“装”的对象是可改变的。

这是和一般基本类型和类类型变量差别很大的地方。

---

继承的概述

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

只要继那个类即可。

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

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

通过 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关键字

super和this的用法相像

this代表本类对象的引用

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

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

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

在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，

我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。

怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，

super是当前对象里面的父对象的引用。

/**
 * 父类
 */
class FatherClass {
    public int value;
 
    public void f() {
        value = 100;
        System.out.println("父类的value属性值=" + value);
    }
}
 
/**
 * 子类ChildClass从父类FatherClass继承
 */
class ChildClass extends FatherClass {
    /**
     * 子类除了继承父类所具有的value属性外， 自己又另外声明了一个value属性， 也就是说， 此时的子类拥有两个value属性。
     */
    public int value;
 
    /**
     * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现， 即重写了f()方法的方法体。
     */
    public void f() {
        super.f();// 使用super作为父类对象的引用对象来调用父类对象里面的f()方法
        value = 200;// 这个value是子类自己定义的那个value，不是从父类继承下来的那个value
        System.out.println("子类的value属性值=" + value);
        System.out.println(value);// 打印出来的是子类自定义的那个value的值，这个值是200
        /**
         * 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时，
         * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法，
         * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。 所以这里打印出来的value值是100。
         */
        System.out.println(super.value);
    }
}
 
/**
 * 测试类
 */
public class ThisDemo {
    public static void main(String[] args) {
        ChildClass cc = new ChildClass();
        cc.f();
    }
}

super

成员变量（在类里面声明）在声明时可以不给它初始化，编译器会自动给这个成员变量初始化，

但局部变量（在方法里面声明）在声明时一定要给它初始化，因为编译器不会自动给局部变量初始化，

任何变量在使用之前必须对它进行初始化。

子类在继承父类value属性的同时，自己也单独定义了一个value属性，所以当我们new出一个子类对象的时候，

这个对象会有两个value属性，一个是从父类继承下来的value，另一个是自己的value。

在子类里定义的成员变量value在声明时也没有给它初始化，所以编译器默认给它初始化为0。

当new一个对象出来的时候，这个对象会产生一个this的引用，这个this引用指向对象自身。

如果new出来的对象是一个子类对象的话，那么这个子类对象里面还会有一个super引用，

这个super指向当前对象里面的父对象。所以相当于程序里面有一个this，this指向对象自己，

还有一个super，super指向当前对象里面的父对象。

super可以调用当前对象的父类对象的构造函数

注意: 子类调用父类的构造方法时，super语句必须是子类构造方法的第一句

class cam0 {
    double size = 10;
    void printsize() {
        System.out.println(size);
    }
}
class cam1 extends cam0 {
    double size = 20;
    void printsize() {
        System.out.println(size);
        System.out.println(super.size);
        super.printsize();
    }
}
public class cam2 {
    public static void main(String args[]) {
        cam1 m = new cam1();
        m.printsize();
    }
}

打印结果：

20.0
10.0
10.0

---

class cam0 {
    public cam0(int a, int b) {
        System.out.println("CS");
    }
}
class cam1 extends cam0 {
    public cam1() {
        super(1, 1);
        System.out.println("bbb");
    }
    public cam1(int a) {
        super(1, 1);
        System.out.println("ccc");
    }
}
public class cam2 {
    public static void main(String args[]) {
        cam1 a = new cam1();
        cam1 b = new cam1(1);
    }
}

打印结果：

CS
bbb
CS
ccc

对象a,b分别调用了父类cam0的构造函数

super可以把当前对象的父类对象的引用作为参数传递给其他方法

---

函数覆盖(Override)　　重写或者复写

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

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

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

覆盖注意事项：

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

　　•静态只能覆盖静态。

覆盖的应用：

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

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

---

子类的实例化过程

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

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

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

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

---

final关键字

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

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

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

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

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

---

抽象类概述

抽象定义：

 

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

 

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

 

抽象类：

 

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

 

包含抽象方法的类就是抽象类。

 

抽象方法的由来：

 

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

并未抽取功能主体，

 

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

 

 

 

 

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

但是并不明确吼叫的细节。

 

 

 

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

(就是把现实世界中的某一类东西，提取出来，用程序代码表示，抽象出来一般叫做类或者接口。)

抽象并不打算了解全部问题，

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

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

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

或者成员变量。

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

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

 

---

抽象类的特点

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

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

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

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

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

真正存在的是狼和狗。

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

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

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

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

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

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

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

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

---

本文原创作者：pipi-changing

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

---

接口

格式：

    interface {}

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

　　•成员常量：public static final

　　•成员函数：public abstract

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

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

---

接口的特点

接口是对外暴露的规则。

接口是程序的功能扩展。

接口的出现降低耦合性。

接口可以用来多实现。

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

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

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

　　　　用处体现在：

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

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

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

　　　　接口的实现：

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

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

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

　　　　接口类型的使用：

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

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

---

接口与抽象类

共  性：	都是不断抽取出来的抽象的概念
区别 1：	抽象类体现继承关系，一个类只能单继承 接口体现实现关系，一个类可以多实现
区别 2：	抽象类是继承，是 "is a "关系 接口是实现，是 "like a"关系
区别 3：	抽象类中可以定义非抽象方法，供子类直接使用 接口的方法都是抽象，接口中的成员都有固定修饰符

---

多态

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

　　例：动物中猫，狗。

 

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

 

　　　　•猫 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在设计异常体系时，将容易出现的情况都封装成了对象。

---

Throwable中的方法

getMessage()

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

toString()

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

printStackTrace()

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

printStackTrace(PrintStream s)

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

---

throws和throw

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抛出，可以不用在函数上声明。

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

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

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

---

包(package)

对类文件进行分类管理。

给类提供多层命名空间。

写在程序文件的第一行。

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

包也是一种封装形式。

classpath

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

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

包之间的访问

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

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

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

四种权限

	public	protected	default	private
同一类中	√	√	√	√
同一包中	√	√	√
子类	√	√
不同包中	√

import *

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

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

---

 Jar包

Java的压缩包

　　•方便项目的携带。

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

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

---

 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就可以双击执行了。

---

处，请多多谅解并欢迎批评指正，不甚感激。