Java EE 第二篇 面向对象

面向对象基础

一、面向对象的概念：

站在更高的层次，省略我们自己对细节的关注，让对象替我们完成具体的工作。我们只需要“使唤”对象即可。面对更复杂的场景，我们可以轻易组织对象应对更灵活、更多的变化，同时可以提高代码的复用性。举例好比我们招来“管家”、“秘书”、“保姆”，我们指挥管家，管家指挥保姆，保姆完成最后做饭的工作，对应实际项目中，则是通过对象指挥其他对象，最终完成工作，我们更多则关注如何设计对象，以及组织对象之间的工作，涉及架构问题。

二、类与对象：

要让对象能够替我们完成工作，就要设计出类，按照类来创建对象，类就好比图纸，对象则是按照图纸生产出来的产品，包含数据和方法。类必须通过对象来使用，不能拿着“图纸”就去干活儿。但是我们也不能直接使用对象，最终能操纵的是一个对象的引用(reference)。在这里有一个很形象的比喻:你可以把车钥匙和车看作是一组对象引用和对象的组合。当你想要开车的时候，你首先需要拿出车钥匙点击开锁的选项，停车时，你需要点击加锁来锁车。车钥匙相当于就是引用，车就是对象，由车钥匙来驱动车的加锁和开锁。并且，即使没有车的存在，车钥匙也是一个独立存在的实体，也就是说，你有一个对象引用，但你不一定需要一个对象与之关联，也就是说可以创建一个空的引用，在需要时与对象进行关联再使用。

类必须存在.java文件中，一个文件可以存在N个类，但是只能存在一个public修饰的类作为主类，类名与文件名保持一致。

类由属性和方法组成：

• 属性：就相当于人的一个个的特征
• 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉

类定义格式：

class 类名称{
    成员属性
    成员方法
}

属性与方法：

属性定义格式：
    数据类型 属性名;
属性定义并赋值的格式：
    数据类型 属性名 = 初始化值;
    
方法定义格式：
    权限修饰符 返回值类型 方法名(形式参数列表){
        //方法体
        return 返回值；
    }

通过对象使用：

类名称 对象名称 = new 类名称() ; //创建引用并与对象进行关联
访问类中的属性： 对象.属性 ;
调用类中的方法： 对象.方法(实际参数列表) ;

三、创建对象内存分析：

1、栈

栈内存通过 '栈指针' 来创建空间与释放空间，指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存，这种移动的方式, 必须要明确移动的大小与范围，这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序 的灵活性，也就是说通过类设计的对象永远不会存储在栈内存中。

只能存储基本数据类型，引用数据类型的引用。

栈内存存取速度非常快，仅次于寄存器。Java中栈区的大小约为2M。

2、堆

存放对象，通过new关键字创建的变量，通过new关键字通知虚拟机在堆内存中开辟一块空间，其中内存的释放由GC负责。GC回收的原则是，栈内存中不存在此对象的引用时，则视其为垃圾，进行回收。堆内存与栈内存不同, 优点在于我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长。

3、方法区

存放类、静态变量、常量、成员方法，常量池中包含static修饰的成员，字符串常量池后来移动到堆内存中。

4、PC寄存器

PC寄存器保存的是 当前正在执行的 JVM指令的 地址。在Java程序中, 每个线程启动时, 都会创建一个PC寄存器。

5、本地方法栈

保存本地(native)方法的地址。一个Native Method就是一个Java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。

四、构造方法

作用： 用于对象初始化。

执行时机： 在创建对象时,自动调用

特点： 所有的Java类中都会至少存在一个构造方法 如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代 码！ 如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。

推荐提供一个无参数构造函数与全参数构造方法，将初始化内容放置其中，在创建对象时自动调用。建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。 当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。 当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

构造器初始化：

对成员属性可以进行默认字段的初始化，如基本类型的初始化，与引用数据类型的初始化默认值，也可以指定数值初始化。

初始化顺序：

静态属性初始化，静态方法块初始化，普通属性初始化，普通方法块初始化，构造函数初始化。

public class LifeCycle {
     private static String staticField = getStaticField();

     static {
        System.out.println(staticField);
        System.out.println("静态方法初始快");
     }

     private String field = getField();
     {
        System.out.println(field);
     }

     public LifeCycle() {
        System.out.println("构造函数初始化");
     }
     public static String getStaticField() {
         String statiFiled = "Static Field Initial";
         return statiFiled;
     }
     public static String getField() {
         String filed = "Field Initial";
         return filed;
     }

     public static void main(String[] argc) {
        new LifeCycle();
     }
}

五、方法的重载

两个方法的名称相同，参数列表的类型或数目或顺序不同（方法签名不同），即可完成重载，实际工作时，编译器会自己选择最合适的那个方法。注意，返回值不是方法签名的一部分，仅返回值类型不同，不能算作重载，参数列表的长度或类型不同即可完成方法的重载。注意区分重载与重写，重写是子类对父类的方法进行子类的实现，而重载是在同一个类中的，重写过程中方法的签名是完全一致不可以改变的，只有实现的逻辑是不一样的。编译器会在重写处标注(Override)，重载则是Overload。

重载的条件：

• 方法名称必须相同。
• 参数列表必须不同（个数不同、或类型不同、参数类型排列顺序不同等)。方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为方法的重载。
• 重载是发生在编译时的，因为编译器可以根据参数的类型来选择使用哪个方法。

重写的原则：

• 重写的方法必须要和父类保持一致，包括返回值类型,方法名,参数列表也都一样。·重写的方法可以使用@0verride注解来标识
• 子类中重写方法的访问权限不能低于父类中方法的访问权限。

六、匿名对象

如果本对象只使用一次，可以使用匿名对象。反之，如果对象的使用至少2次，则必须有引用指向这个对象，否则创建之后就找不到了。匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被G·C回收。 只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。

七、面向对象的三大特征

封装、继承、多态。

面向对象进阶

一、封装

隐藏类中的数据域，对类中的数据属性进行封装，提供访问器与更改器进行数据的操作。建议在类的设计中，对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。

class Person{
    private String name ; // 表示姓名
    private int age ; // 表示年龄
    void tell(){
        System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ;
    }
    public void setName(String str){
        name = str ;
    }
    public void setAge(int a){
        if(a>0&&a<150)
            age = a ;
    }
    public String getName(){
        return name ;
    }
    public int getAge(){
        return age ;
    }
};

二、this与super关键字

this指向当前创建的对象，可以使用this完成属性的访问，调用方法，避免由于方法参数与类中属性重名而导致方法的工作异常。如果你把 this 理解为指向自身的一个引用，那么super就是指向父类的一个引用。super关键字和 this一样，你可以使用super.对象来引用父类的成员，super(参数)调用父类的构造函数。

三、static静态

可修饰：代码块、成员变量、成员方法。

被static修饰的成员变量与成员方法称为类属性与类方法，在类加载时即可使用，不需要创建对象完成调用，使用类名即可调用。在内存中，均存储在方法区，为所有对象所共有，只存储一份，不会随多个对象的创建而产生多个内存中的副本。

静态可以不可访问非静态，而非静态能访问静态，原因是对象不一定已经创建，使用静态可能是类加载时期，没有创建具体对象是不能访问非静态的。

四、代码块

1、构造代码块

在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。可以随对象的创建反复执行多次。

2、静态代码块

在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会执行一次的代码块。

构造顺序：静态代码块 --> 构造代码块 --> 构造方法

五、权限修饰符：

继承：

继承是所有0OP(Object Oriented Programming)语言和Java语言都不可或缺的一部分。只要我们创建了一个类，就隐式的继承自0bject父类，只不过没有指定。如果你显示指定了父类，那么你继承于父类，而你的父类继承于Object类。继承双方具有属性上的共性，并可能发生方法的重写。

组合：

组合其实不难理解，就是将对象引用置于新类中即可。组合也是一种提高类的复用性的一种方式。如果你想让类具有更多的扩展功能，你需要记住一句话多用组合，少用继承。

public class SoccerPlayer {
     private String name;
     private Soccer soccer;
}
public class Soccer {
    private String soccerName;
}

继承与组合的区别：

代理：

除了继承和组合外，另外一种值得探讨的关系模型称为代理。代理的大致描述是，A想要调用B类的方法，A不直接调用，A会在自己的类中创建一个B对象的代理，再由代理调用B的方法。

六、单例模式

单例设计模式：保证程序在内存中只有一个对象存在（被程序所共享)

1、懒汉式

//随着类的加载在内存中对象为null，当调用 getInstance 方法时才创建对象（延迟加载）
class Single{
    private Single(){}
    private static Single s1 = null;
    public static Single getInstance(){
        if(s1 == null){
            s1 = new Single();
        }
        return s1;
    }
}

2、饿汉式

//随着类的加载直接创建对象（推荐开发中使用）
class Single2{
    private Single2(){}
    private static Single2 s = new Single2();
    public static Single getInstance(){
        return s;
    }
    void print(){
        System.out.println("Hello World!");
    }
}

实现步骤：

1. 保证一个类只有一个实例，实现方式：构造方法私有化
2. 必须要自己创建这个实例，实现方式：在本类中维护一个本类对象（私有，静态）
3. 必须向整个程序提供这个实例，实现方式：对外提供公共的访问方式（getInstance方法，静态）

七、包

1、简介

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。 包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

2、使用规则

- 包中java文件的定义：
    在.java文件的首部， 必须编写类所属哪个包， 格式：
    package 包名;
- 包的定义：
    通常由多个单词组成， 所有单词的字母小写， 单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目名.模块名....”。
规范由来：
    由于Java面向对象的特性，每名Java开发人员都可以编写属于自己的Java Package，为了保障每个JavaPackage命名的唯一性，在最新的Java编程规范中，要求开发人员在自己定义的包名前加上唯一的前缀。由于互联网上的域名称是不会重复的，所以多数开发人员采用自己公司在互联网上的域名称作为自己程序包的唯一前缀。例如：com.java.xxx

导入包中的某个类：
import 包名.类名;

八、main方法详解：

main()方法一直写到了今天：
public static void main(String args[])
    以上的各个参数的含义如下：
        · public：表示公共的内容，可以被所有操作所调用
        · static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09
        · void：表示没有任何的返回值操作
        · main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main
        · String[] args：字符串数组，接收参数的

所有的参数在执行类的时候以空格进行分割。
java StaticDemo10 1 2 3 4 5 6 7
但是，要输入的是以下几种参数"hello world"、"hello vince"、"hello mjw"。
因为以空格分割，所以以上的三组参数会当做六组参数输入，那么此时如果要想完成有空格的内容输入，则参数需
要使用""括起来。
java StaticDemo10 "hello world" "hello vince" "hello mjw"

九、final的用法

• final的意思是最后的、最终的,它可以修饰类、属性和方法。
• final修饰类时，表明这个类不能被继承。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
• final修饰方法时，表明这个方法不能被任何子类重写，因此，如果只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final。
• final修饰变量分为两种情况，一种是修饰基本数据类型，表示数据类型的值不能被修改;一种是修饰引用类型，表示对其初始化之后便不能再让其指向另一个对象。
  
  
  

面向对象高级

一、抽象类

//使用abstract class关键字声明
//一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。
//抽象方法也要由abstract关键字声明
abstract class 类名{ // 抽象类
    public abstract void 方法名() ; // 抽象方法，只声明而未实现(没有{}定义的方法体)的方法
}

注意：

1. 抽象类不可以被实例化（细节都不确定，没有办法实例化），无法通过new关键字进行构造。但是抽象类可以有构造方法，子类继承抽象类时，可以创建抽象类对象，只不过是JVM帮助创建，由JVM进行实例化，我们自己无法创建。子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默 认是无参的），之后再调用子类自己的构造方法。
2. 继承抽象类的子类必须重写抽象类的所有抽象方法，只要还有一个抽象的方法没有重写实现，则子类页也必须声明为抽象类。
3. 抽象类不可以被final声明：子类无从继承，该抽象类无法被实现。
4. 抽象类必须使用public与protected进行修饰，默认为public，否则private修饰下，子类无法继承。

二、接口

一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。使用interface关键字进行声明：

interface 接口名称{
    全局常量;
    抽象方法;
}

面向接口编程思想：

接口是定义（规范，约束）与实现（名实分离的原则）的分离，通过继承接口来实现接口中的方法，完成实现。

优点：

1. 降低程序的耦合性
2. 易于程序扩展
3. 有利于程序维护

全局常量和抽象方法简写：

JVM会自动帮助我们完成，全局常量编写时， 可以省略public static final 关键字，抽象方法编写时， 可以省略 public abstract 关键字。

1、全局常量编写时， 可以省略public static final 关键字，例如：
    public static final String INFO = "内容" ;
    简写后：
    String INFO = "内容" ;
2、抽象方法编写时， 可以省略 public abstract 关键字， 例如：
    public abstract void print() ;
    简写后：
    void print() ;

接口的实现：

实现时使用implements关键字实现，java中的类只能单继承类，但是可以对接口进行多实现，通过接口实现别的语言中的多继承。

class 子类 implements 父接口1,父接口2...{

}

接口的继承：

允许对接口进行多继承，因为都是抽象的部分，不存在具体实现：

interface C extends A,B{
    
}

注意：一个接口要想使用，必须依靠子类实现接口中的所有抽象方法。

重点：接口和抽象类的区别

1. 抽象类要被子类继承，接口要被类实现。
2. 接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3. 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4. 抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5. 抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
6. 接口不能有构造方法，但是抽象类可以有
7. 可以用接口变量引用一个实现了接口的类对象。

三、多态

概念：

多态：就是对象的多种表现形式，（多种体现形态）

体现：

1. 父类变量可以引用父类和子类对象（对象多态性，向上转型）。子类变量引用父类实例需要实现强转。
2. 方法的重载与重写（方法的多态）

重载与重写的区别：

重载： 一个类中方法的多态性体现 ，多个方法签名，编译器来选择最合适的那个。

重写： 子父类中方法的多态性体现。调用继承链上最近的子父类同名方法。

对象的类型转换：

· 向上转型：将子类实例变为父类实例
    |- 格式：父类 父类对象 = 子类实例 ；
· 向下转型：将父类实例变为子类实例
    |- 格式：子类 子类对象 = （子类）父类实例 ；

四、insatnceof方法

给自定义类重写equals方法时调用，判断某个对象是否为某个类的实例，返回boolean类型的值。

五、Object类

所有类的父类，自定义类继承自Object，需要重写toString与equals和hashcode三个方法，后两个配合使用。

使用Object可以接收任意的引用数据类型。（多态）

toString

建议重写Object中的toString方法。 此方法的作用：返回对象的字符串表示形式。
Object的toString方法， 返回对象的内存地址

equals

建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。
Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。
equals方法重写时的五个特性：
    自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。
    对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
    传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后
    x.equals(z)应该返回true 。
    一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象
    上的equals比较中使用的信息。
    非空性 ：对于任何非空的参考值x ， x.equals(null)应该返回false 。

六、内部类（非重点）

概念：定义在别的类内部的类。由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息，那么，如何表示内部类的信息呢?可以使用美元符号来表示，比如OuterClass美元符号InnerClass.class。这里InnerClass就是OuterClass 的一个内部类。也就是说，每个内部类都能独立地继承一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。这也是隐藏了内部实现细节。内部类拥有外部类的访问权。在这段代码中，InnerClass就是OuterClass 的一个内部类。也就是说，每个内部类都能独立地继承一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。这也是隐藏了内部实现细节。内部类拥有外部类的访问权。内部类不仅仅能够定义在类的内部，还可以定义在方法和作用域内部，这种被称为局部内部类，除此之外，还有匿名内部类、内部类可以实现 Java 中的 多重继承。下面是定义内部类的方式

1、成员内部类

class Outer {
    private double x = 0;
    public Outer(double x) {
        this.x = x;
    }
    class Inner { //内部类
        private double x = 1.0
        public void say() {
            System.out.println("x="+x);//默认使用的是内部类的x,打印1.0
             System.out.println("x="+Outer.this.x);//使用的是外部类的x,打印0            
        }
    }
}

特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员），因为外部类不创建对象，内部类是实现不了的，当内部类可以使用时，外部类的成员与方法都已经有了。

Outer o = new Outer();
Outer.Inner i = o.new Inner();//使用内部类

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。

如果要访问外部类的同名成员，需要以下面的形式进行访问：

**外部类.this.成员变量 **

外部类.this.成员方法

2、局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或 者该作用域内。

注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3、匿名内部类

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：
    new 父类构造器（参数列表）|实现接口（）
    {
        //匿名内部类的类体部分
    }
在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

注意：

1. 使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或 者实现一个接口。
2. 匿名内部类中是不能定义构造函数的。
3. 匿名内部类中不能存在任何的静态成员变量和静态方法。
4. 匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5. 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
6. 只能访问final型的局部变量（单独编译为字节码文件，如果不是final，会造成引用与拷贝不一致的问题）

4、静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。 静态内部类是不需要依赖于外部类对象的（不需要先创建外部类实例），这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法（静态不能访问非静态），因为此时内部已经有了，外部可能还没有。

public class Test {
    public static void main(String[] args) {
        Outter.Inner inner = new Outter.Inner();
    }
}
class Outter {
    public Outter() {
    }
    static class Inner {
        public Inner() {
        }
    }
}
    

七、包装类

自动装箱与自动拆箱：

Float f = 10.3f ; // 自动装箱
float x = f ; // 自动拆箱
System.out.println(f * f) ; // 直接利用包装类完成
System.out.println(x * x) ; // 直接利用包装类完成

字符串装换：

//使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。
//在Integer类中提供了以下的操作方法：
public static int parseInt(String s) ：将String变为int型数据
//在Float类中提供了以下的操作方法：
public static float parseFloat(String s) ：将String变为Float
//在Boolean 类中提供了以下操作方法：
public static boolean parseBoolean(String s) ：将String变为boolean

八、可变参数

返回值类型 方法名称(数据类型…参数名称){
    //参数在方法内部 ， 以数组的形式来接收
}

int calculateSum(int...nums){//nums为长度不限的可变参数，注意可变参数一定在参数列表的最后
    int sum = 0;
    for(int num:nums){
        n += num;
    }
    return sum;
}

九、递归

函数要调用自身，程序要有出口。