java--面向对象

权限修饰符

权限修饰符: 限定对象对该类成员的访问权限.

对于class的权限修饰只可以用public和default(缺省)。
public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。

java类

类的成员组成

• 属性(成员变量)

// 代码格式

修饰符 属性的类型 属性名 = 初始化值;

• 方法(成员方法)

// 代码格式

修饰符 返回值类型 方法名(参数类型 形参1,参数类型 形参2 , ..){
    方法体语句;
}
// 修饰符 : public private protected ..
// 返回值类型: 通过return返回.如果没有返回值使用void
// 参数类型: 该形式参数的类型
// 形式参数(形参): 方法被调用时候用来接受外界传入的数据的变量
// 实参: 方法被调用时候实际传递给形参的数据 

方法的重载(overload)

概念:

在一个类里面允许存在一个以上同名的方法,只要参数的个数,参数类型不同即可(参数列表).

特点:

1. 与返回值,返回值类型是无关的.
2. 与参数列表顺序有关

• 构造器(constructor)

语法格式:

修饰符  类名 (参数列表) {
        初始化语句；
} 

特征：

1. 如果不显示的声明一个类的构造器,那么程序会默认提供一个空参的构造器
2. 如果显示的声明了构造器,那么默认的构造器就不再提供
3. 名称与类同名
4. 不需要声明返回值类型
5. 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

作用:

1. 创建对象
2. 给对象属性进行初始化

注意事项:

1. 每个类至少一个构造器
2. 默认构造器的修饰符与所属类的修饰符一致
3. 一个类可以创建多个重载的构造器
4. 父类的构造器不可被子类继承

• 初始化块

概念：　一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block )，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。

作用:　对Java对象进行初始化

程序的执行顺序：

• 非静态代码块：没有static修饰的代码块

       1.可以有输出语句。
       2.可以对类的属性、类的声明进行初始化操作。
       3.可以调用静态的变量或方法。
       4.若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
       5.每次创建对象的时候，都会执行一次。且先于构造器执行

• 静态代码块：用static 修饰的代码块

    1.可以有输出语句。
    2.可以对类的属性、类的声明进行初始化操作。
    3.不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
    4.若有多个静态的代码块，那么按照从上到下的顺序依次执行。
    5.静态代码块的执行要先于非静态代码块。
    6.静态代码块只执行一次

• 内部类

概念: 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

内部类的分类:

• 成员内部类（static成员内部类和非static成员内部类）声明在类内部且方法外

1. 是外部类的一个成员: 
    - 可以有修饰符(4个)
    - 可以被static final abstract修饰
    - 可以调用外部类属性,方法
2. 具有类的特点:
    - 可以被abstract修饰 
    - 在其内部可以定义属性,方法,构造器

• 局部内部类（不谈修饰符
• 匿名内部类 声明在类的方法里面

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类

类的访问机制

- 同一个类的访问机制: 类中的方法可以直接访问类中的成员变量(static方法访问非static变量是不可以的)

- 不同类的访问机制: 先创建需要访问的那个类的对象,再通过该对象去访问类中定义的类成员

对象的创建与使用

// 创建对象
new + 构造器 = 一个新的对象
访问对象成员: 对象名.对象成员

对象的内存解析:

成员变量自动初始化:

一个对象被创建时候,会自动对类的成员变量进行初始化赋值.

匿名类对象:

概念: 不定义对象的句柄,直接使用对象的方法.

适用情况:

1. 对一个对象只进行一次方法调用
2. 把匿名对象作为一个实参传递给方法调用

可变个数的形参

可变个数的形参方法与同名方法可以构成重载.

格式:

方法的形参: 数据类型 ... 形参名

实际调用时候,参数个数从0到无穷

注意事项:
- 方法中如果存在可变个数的形参,那么一定要声明在方法形参的最后
- 一个方法里面,最多声明一个可变个数的形参

方法的参数传递

理解实参与形参的概念:

形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值

java的参数传递方式只有一种: 值传递

将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

1. 形参是基本数据类型: 把实参的值传递给形参的基本数据类型变量
2. 形参是引用数据类型: 把实参的引用类型变量的值(指针)传递给形参的引用数据类型变量

　this关键字

它在方法内部使用，即表示为这个方法所属对象的引用；
它在构造器内部使用，即表示为该构造器正在初始化的对象

this表示当前对象，可以调用类的属性、方法和构 造器.
当在方法内需要用到调用该方法的对象时，就用this.

• 使用this，调用属性、方法

1. 当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员

2. 在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性

• 使用this调用本类的构造器

this可以作为一个类中构造器相互调用的特殊格式.

- this()必须放在构造器的首行！
- 使用this调用本类中其他的构造器，保证至少有一个构造器是不用this的。

　javaBean

概念: JavaBean是一种Java语言写成的可重用组件。
javaBean，是指符合如下标准的Java类：

1. 类是公共的
2. 有一个无参的公共的构造器
3. 有属性，且有对应的get、set方法

UML类图

+ 表示 public 类型， - 表示 private 类型，#表示protected类型

方法的写法: 
方法的类型(+、-)  方法名(参数名： 参数类型)：返回值类型

package关键字

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包).

格式:
package 顶层包名.子包名 ;

        pack\Test.java
        package p1;    //指定类Test属于包p1
        public class Test{
                public void display(){
            System.out.println("in  method display()");
                }
        }

规则:

包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

包通常用小写单词，类名首字母通常大写

JDK中主要包的介绍:

1. java.lang ----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
2. java.net ----包含执行与网络相关的操作的类和接口。
3. java.io ----包含能提供多种输入/输出功能的类。
4. java.util ----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5. java.text ----包含了一些java格式化相关的类
6. java.sql ----包含了java进行JDBC数据库编程的相关类/接口
7. java.awt ----包含了构成抽象窗口工具集（abstract window toolkits）的 多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
8. java.applet ----包含applet运行所需的一些类。

import关键字

概念:为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。

语法格式:

import  包名[.子包名…]. <类名 |*>

规则:

1. 若引入的包为：java.lang，则编译器默认可获取此包下的类，不需要再显示声明。
2. import语句出现在package语句之后、类定义之前
3. 一个源文件中可包含多个import语句
4. 可以使用import lee.* ;语句，表明导入lee包下的所有类。而lee包下sub子包内的类则不会被导入。import lee.sub.*;
5. import语句不是必需的，可坚持在类里使用其它类的全名
6. JDK 1.5加入import static语句

static关键字

概念: 静态的,可以修饰属性,方法,代码块,内部类..

类变量 static修饰属性. –> 如果想让一个类的所有实例共享数据，就用类变量！

类变量的特点:

1. 随着类的加载而加载
2. 优先于对象存在
3. 修饰的成员，被所有对象所共享
4. 访问权限允许时，可不创建对象，直接被类.属性调用,因为出生早于对象
5. 类变量存在静态域中
6. 当其中一个实例对象对其进行修改,会影响其他对象求其的调用.

类方法: static 修饰方法

类方法的特点:

1. 随着类的加载而加载,在内存中独一份
2. 直接被类.方法调用
3. 在static方法内部只能访问类的static属性，不能访问类的非static属性,非静态方法可以访问静态属性
4. 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)
5. 重载的方法需要同时为static的或者非static的。

final 关键字

1. final标记的类不能被继承。提高安全性，提高程序的可读性。
2. final标记的方法不能被子类重写
3. final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。内容不可修改.
4. final标记的成员变量必须在声明的同时或在每个构造方法中或代码块中显式赋值，然后才能使用。

抽象类

用abstract关键字来修饰一个类时，这个类叫做抽象类.

1. 不可以被实例化
2. 抽象类有构造器(凡是类都有构造器)
3. 抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体

用abstract来修饰一个方法时，该方法叫做抽象方法.

1. 只有方法的声明，没有方法的实现。以分号结束.
2. 含有抽象方法的类必须被声明为抽象类。
3. 抽象方法只保留功能,具体的执行交给继承抽象类的子类，由子类进行重写.
4. 若没有重写全部的抽象方法，仍为抽象类

格式:

abstract int abstractMethod( int a );

注意:　

不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法

抽象思维:

当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

接口

概念: 功能

接口(interface)是抽象方法和常量值的定义的集合--()。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现．

Java不支持多重继承。有了接口，就可以得到多重继承的效果．
一个类可以实现多个接口，接口也可以继承其它接口．

格式：实现接口类

class SubClass implements InterfaceA{ }

定义一个接口:

    interface Runner {
        // 常量 : 所有常量都是通过public static final 修饰
        int ID = 1;    
        // 抽象方法 : 都是通过public abstract 修饰
        void start();

    }

接口特点:

1. 用interface来定义。
2. 接口中的所有成员变量都默认是由public static final修饰的。
3. 接口中的所有方法都默认是由public abstract修饰的。
4. 接口没有构造器。
5. 接口采用多继承机制。
6. 接口的主要用途就是定义一种功能,被实现类实现。（面向接口编程）
7. 与继承关系类似，接口与实现类之间存在多态性
8. 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
9. 如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类
10. 接口也可以继承另一个接口，使用extends关键字
11. 在开发中，一个类不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口。

接口用法总结:

1. 通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。
2. 通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。
3. 接口主要用来定义规范。解除耦合关系

接口与抽象类的关系:

面向对象的三大特征

• 封装

解决的问题:

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。

概念: 把信息进行封装与隐藏

实现封装的原理:

通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作.

目的:
1. 隐藏一个类中不需要对外提供的实现细节；
2. 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
3. 便于修改，增强代码的可维护性

• 继承

为什么需要继承?

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

此处的多个类称为子类，单独的这个类称为父类（基类或超类）.

语法格式:

class Subclass extends Superclass{ }

作用:

1. 继承的出现提高了代码的复用性。
2. 继承的出现让类与类之间产生了关系，提供了多态的前提。
3. 子类继承了父类，就继承了父类的方法和属性。
4. 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
5. 继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

规则:

子类不能直接访问父类中私有的(private)的成员变量和方法。

java只支持单继承,不支持多继承.

单继承概念: 一个子类只能有一个父类.

方法的重写(override)

概念: 在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

重写的要求：

1. 重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
2. 重写方法不能使用比被重写方法更严格的访问权限。
3. 重写和被重写的方法须同时为static的，或同时为非static的
4. 子类方法抛出的异常不能大于父类被重写方法的异常

super关键字

在Java类中使用super来调用父类中的指定操作:如

1. super可用于访问父类中定义的属性
2. super可用于调用父类中定义的成员方法
3. super可用于在子类构造方法中调用父类的构造器

注意:

1. 尤其当子父类出现同名成员时，可以用super进行区分
2. super的追溯不仅限于直接父类
3. super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

调用父类的构造器:

1. 子类中所有的构造器默认都会访问父类中空参数的构造器
2. 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行
3. 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

this与super的区别:

子类对象的实例化过程:

• 多态

概念: 是面向对象中最重要的概念，在java中有两种体现：

• 方法的重载(overload)和重写(overwrite)。
• 对象的多态性 ——可以直接应用在抽象类和接口上

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定.若编译时类型和运行时类型不一致，就出现多态（Polymorphism）

多态出现的前提:

1. 需要存在继承或者实现关系
2. 要有覆盖操作

多态 — 虚拟方法调用

// 正常情况的掉用

    Person e = new Person();
    e.getInfo();
    Student e = new Student();
    e.getInfo();

// 虚拟情况调用

        Person e = new Student();
        e.getInfo();    //调用Student类的getInfo()方法

编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

向上转型: 子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法.

    Student m = new Student();
    m.school = “pku”;   //合法,Student类有school成员变量
    Person e = new Student(); 
    e.school = “pku”;   //非法,Person类没有school成员变量
属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

成员方法的多态:

编译时：要查看引用变量所属的类中是否有所调用的方法。
运行时：调用实际对象所属的类中的重写方法

多态性在传参数时候的应用:

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

instanceof 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof  A值也为true。

对象的类型转换(casting)

基本数据类型的casting:

1. 自动数据类型转换
2. 强制数据类型转换

Java对象的强制类型转换称为造型:

1. 从子类到父类的类型转换可以自动进行
2. 从父类到子类的类型转换必须通过造型(强制类型转换)实现
3. 无继承关系的引用类型间的转换是非法的
4. 在造型前可以使用instanceof操作符测试一个对象的类型

Object类

特征：

1. Object类是所有Java类的根父类
2. 如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类 

==操作符与equals方法

==操作符

1. 基本数据类型: 基本类型比较值:只要两个变量的值相等，即为true
2. 引用类型比较引用(是否指向同一个对象):只有指向同一个对象时，==才返回true.
3. 用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错；

equals()

格式:

obj1.equals(obj2)

1. 所有类都继承了Object，也就获得了equals()方法。还可以重写。
2. 只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。 

注意事项:

当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
原因：在这些类中重写了Object类的equals()方法。

包装类

针对八种基本定义相应的引用类型—包装类（封装类）

装箱: 基本数据类型包装成包装类的实例,通过包装类的构造器实现,还可以通过字符串参数构造包装类对象：

int i = 500;   Integer t = new Integer(i);
Float f = new Float(“4.56”);
Long l = new Long(“asdf”);  //NumberFormatException

拆箱: 获得包装类对象中包装的基本类型变量

调用包装类的.xxxValue()方法：
boolean b = bObj.booleanValue();