面向对象（一）

万物皆对象

面向过程：采用面向过程必须了解整个过程，每个步骤都有因果关系，每个因果关系都构成了一个步骤，多个步骤就构成了一个系统，因为存在因果关系每个步骤很难分离，非常紧密，当任何一步骤出现问题，将会影响到所有的系统

面向对象：面向对象会 将世界分割成不同的单元，实现各个对象，如果完成某个功能，只需要将各个对象协作起来就可以。

举例：下棋

面向过程：白方先下，拿旗子，思考，放棋子，黑子后下，拿旗子。。。。每次下棋都必须有一方法

面向对象：白方黑方都有其自己的下棋方法，轮到白方或黑方时直接调用自己的下棋方法

面向对象的意义：代码的复用性，易于扩展

类与对象：类就是一类事物共性的一个描述，对象就是类的一个实例。

类的定义：

类的修饰符 class 类名 extends 父对象名称 implements 接口名称 {

类体：属性和方法组成

}

方法里边的变量叫做局部变量，方法外边类里面的变量叫做成员变量

面向对象的三大特征：封装、继承、多态

封装：

封装其实就是封装属性，避免了外界直接对属性的操作。一般在类中用private来封装属性，对外提供获取这个属性的方法

构造函数：

构造方法主要用来创建类的实例化对象，可以完成创建实例化对象的初始化工作，声明格式：

构造方法修饰词列表 类名（方法参数列表）

 

构造方法修饰词列表：public、protected、private

类的构造方法和普通方法一样可以进行重载

构造方法具有的特点：

构造方法名称必须与类名一致

构造方法不具有任何返回值类型，即没有返回值，关键字void也不能加入，加入后就不是构造方法了，就成了普通的方法了

任何类都有构造方法，如果没有显示的定义，则系统会为该类定义一个默认的构造器，这个构造器不含任何参数，如果显示的定义了构造器，系统就不会创建默认的不含参数的构造器了。

this关键字：

this关键字指的是当前调用的对象，如果有100个对象，将有100个this对象指向各个对象

this关键字可以使用在：

当局部变量和成员变量重名的时候可以使用this指定调用成员变量

通过this调用另一个构造方法

在构造方法中，如果使用this方法调用和其他构造方法，那么this语句必须放在第一句。如果不放在第一句，会发生编译错误

需要注意：this只能用在构造函数和成员方法内部(声明变量也可以用)，static标识的方法里是不能使用this。

static关键字：

static修饰符可以修饰：变量、方法和代码块

用static修饰的变量和方法，可以采用类名直接访问

用static声明的代码块为静态代码块，JVM加载类的时候，会执行静态代码块中的内容

static声明的变量，所有通过该类new出的对象，都可以共享，通过该对象都可以直接访问static声明的变量，也可以采用类直接访问，所以我们也称其为类变量

静态方法中是不能直接调用实例变量、实例方法和使用this的，也就是说和实例相关的他都不能直接调用

main方法：

public：表示全局所有，其实就是封装性

static：静态的，也就是说它描述的方法只能通过类调用

main：系统规定的

String[] args 参数类型也是系统规定的

一个类在什么时候加载：

            1.   new一个对象的时候加载

            2.没有创建对象，访问类中静态成员（方法和属性）

            3.创建子类，先加载父类，在加载子类

            4.没有创建对象，访问类中静态成员（不确定的值）

单例设计模式：

目的：为了避免重复创建对象，浪费资源

单例模式的三要素：

在类体中需要具有静态的私有的本类型的变量

构造方法必须是私有的

提供一个公共的静态的入口点方法

懒汉式和饿汉式有什么不同！！

懒汉式的特点在于实例延迟加载。

懒汉式有没有什么问题。有。如果多线程访问时会出现安全问题。可以加同步来解决，用同步代码块和同步函数都行。但稍微有些低效。用双重判断的形式能结局效率问题。加同步的时候 使用的锁是哪一个 ，该类所属的字节码文件对象。

饿汉式：

public class SingletonPatternTest01 {

public static void main(String[] args) {

Singleton.getInstance().test();

}

}

 

class Singleton {

//静态私有的本类的成员变量

private static Singleton instance = new Singleton();

//私有的构造方法

private Singleton() {

}

//提供一个公共的静态的入口点方法

public static Singleton getInstance() {

return instance;

}

public void test() {

System.out.println("----------test----------");    

}

}

懒汉式：

public class SingletonPatternTest01 {

public static void main(String[] args) {

Singleton.getInstance().test();

}

}

 

class Singleton {

//静态私有的本类的成员变量

private static Singleton instance;

//私有的构造方法

private Singleton() {

}

//提供一个公共的静态的入口点方法

public static Singleton getInstance() {

If(instance == null)   instance = new Singleton;

return instance;

}

public void test() {

System.out.println("----------test----------");    

}

}

继承：

1.继承是面向对象的重要概念，软件中的继承和现实中的继承概念是一样的

2.继承是实现软件可重用性的重要手段，如：A继承B，A就拥有了B的所有特性，如现实世界中的儿子继承父亲的财产，儿子不用努力就有了财产，这就是重用性

3.java中只支持类的单继承，也就是说A只能继承B，A不能同时继承C

4.java中的继承使用extends 关键字，语法格式：

[修饰符] class 子类 extends 父类 {

 

}

方法的覆盖：

方法的覆盖的条件：

必须要有继承关系

覆盖只能出现在子类中，如果没有继承关系，不存在覆盖，只存在重载

在子类中被覆盖的方法，必须和父类中的方法完全一样，也就是方法名，返回类型、参数列表，完全一样

子类方法的访问权限不能小于父类方法的访问权限

子类方法不能抛出比父类方法更多的异常，但可以抛出父类方法异常的子异常

父类的静态方法不能被子类覆盖（不被称为覆盖）,静态方法处理的时候，访问权限发生错误也会提示覆盖

父类的私有方法不能覆盖

覆盖是针对成员方法，而非属性

为什么需要覆盖？

就是要改变父类的行为。

super关键字：

super关键字的作用：

调用父类的构造方法

调用父类的成员方法

需要注意：super只能应用在成员方法和构造方法中，不能应用在静态方法中（和this是一样的），如果在构造方法中使用必须放在第一行

为什么会有super关键字？

因为子类必须要调用父类的构造方法，先把父类构造完成，因为子类依赖于父类，没有父，也就没有子

有时需要在子类中显示的调用父类的成员方法

那么我们以前为什么没有看到super，而且我们也有继承，如：Student继承了Person？

因为子类中我们没有显示的调用构造方法，那么他会默认调用父类的无参构造方法，此种情况下如果父类中没有无参构造方法，那么编译时将会失败

构造方法不存在覆盖的概念，构造方法可以重载

final关键字：最终的

被final修饰的变量不能被修改，并且必须显示初始化。

被final修饰的方法不能被覆盖。

被final修饰的类不能被继承。

被final修饰的引用只能指向一个对象。

抽象类：

1.在java中采用abstract关键字定义的类就是抽象类，采用abstract关键字定义的方法就是抽象方法

2.抽象的方法只需在抽象类中，提供声明，不需要实现

3.如果一个类中含有抽象方法，那么这个类必须定义成抽象类

4.如果这个类是抽象的，那么这个类被子类继承，抽象方法必须被复写。如果在子类中不复写该抽象方法，那么必须将此方法再次声明为抽象方法

5.抽象的类是不能实例化的，就像现实世界中人其实是抽象的，张三、李四才是具体的

6.抽象类不能被final修饰

7.抽象方法不能被final修饰，因为抽象方法就是被子类实现的

抽象类中可以包含方法实现，可以将一些公共的代码放到抽象类中，另外在抽象类中可以定义一些抽象的方法，这样就会存在一个约束，而子类必须实现我们定义的方法，如：teacher必须实现printInfo方法，Student也必须实现printInfo方法，方法名称不能修改，必须为printInfo，这样就能实现多态的机制，有了多态的机制，我们在运行期就可以动态的调用子类的方法。所以在运行期可以灵活的互换实现。

接口：

接口我们可以看作是抽象类的一种特殊情况，在接口中只能定义抽象的方法和变量

1) 在java中接口采用interface声明

2) 接口中的方法默认都是public abstract的，不能更改

3) 接口中的变量是public static final类型的，不能更改，所以必须显示的初始化

4) 接口不能被实例化，接口中没有构造函数的概念

5) 接口之间可以继承，但接口之间不能实现

6) 接口中的方法只能通过类来实现，通过implements关键字

7) 如果一个类实现了接口，那么接口中所有的方法必须实现

8) 一类可以实现多个接口

接口的好处：

采用接口明确的声明了它所能提供的服务

解决了Java单继承的问题 

实现了可接插性（重要）

接口和抽象类的区别？

a) 接口描述了方法的特征，不给出实现，一方面解决java的单继承问题，实现了强大的可接插性

b) 抽象类提供了部分实现，抽象类是不能实例化的，抽象类的存在主要是可以把公共的代码移植到抽象类中

c) 面向接口编程，而不要面向具体编程（面向抽象编程，而不要面向具体编程）

d) 优先选择接口（因为继承抽象类后，此类将无法再继承，所以会丧失此类的灵活性）