JAVA SE面向对象

面向过程：

    如果使用面向过程的思维考虑问题，考虑的就是过程和步骤。（think how to do!）

面向对象：

    考虑的是有几个对象，对象之间如何访问，这些对象能够干什么。（think what to do!）

对象：
        在JAVA的眼里，无论什么都是对象。对象的组成(属性、成员变量：名词，行为、成 员方法：动词)

类：

        对象的模板，具有相同属性和行为的一组对象的集合，也是一种JAVA自定义的数据类 型，在JAVA中，先创建类，再通过类来创建具体的对象。同一个文件中，只能有一个 类是public，就 是具体main方法的那个。

对象和类的区分：

    对象是具体存在的，而类是抽象的概念。

字符串连接符：

    当+号的一边是字符串类型的时候，+号就是字符串连接符。

构造方法：

    最主要的作用就是用来创建对象，构造方法是一种特殊的方法。①与类名相同，没有返 回值，连void都没有。②每个类都有一个隐式的构造方法，隐式的构造方法，没有参 数，没有方法。③如果我们手动添加一显示的构造方法，则隐式的构造方法不存在。④ 构造方法只有和new关键字一起使用来创建对象。⑤初始化成员变量，this表示当前对 象的引用。

引用数据类型：

       保存的不是真实的对象，而是保存的是对象在堆中的内在地址，通过地址可以找到真实的对象。

面向对象思想：

    1.先找有几个对象；

    2.通过对象找出有几个类；

    3.找出每个类中有哪些属性和方法；

    4.调用方法实现功能。

    例题：张三吃了李四一根头发。

    解题步骤：

           第一步找对象：张三、李四、头发；

           第二步找类：人、头发；

           第三步找属性和方法：属性（名字、头发）；方法（吃）。

    示例代码：

    

public static void main(String[] args){
    Person p1 = new Person();
    p1.name = "张三";
    Person p2 = new Person();
    p2.name = "李四";
    p2.h = new Hair();
    p1.eat(p2.h);
}
class Person{
    String name;
    Hair h;
    public void eat(Hair hair){
    }
}
class Hair{

}

专家模式：

    方法改变谁的状态，方法就属于谁。状态：属性的值（成员变量的值）。改变对象的状态其实就是改变成员变量的值。

引用数据类型：

    引用数据类型：类、数组等等。

    Code segement    代码区（字节码）

    Heap segement    堆区（对象、成员变量）

    Stack segement    栈区（局部变量）

    Static segement    静态区（静态变量和字符常量）

    静态区是栈的一个特殊区域，其中的数据不能重复。

    堆和栈的区别：堆可以保存大数据量的内容，执行速度慢；而栈保存小数据量的内容，执行速度快。

    基本数据类型和引用数据类型的区别：基本数据类型保存的是真实的值，引用数据 

    类型中保存的不是对象，而是对象的地址，通过地址，可以找到在堆中的对象，所

    以变量不是对象，而是对象的引用。

this指针：

    this 指针：每个对象都有this指针，相当于当前对象的引用。

    成员变量和局部变量重名，解决的办法：

    使用关键字this   this.name（成员变量）

成员变量默认初始化：

    在JAVA中成员变量会默认初始化，默认值为0（整数类型）、false（布尔类型）、空  

字符（字符类型）、null（引用类型）。null 值的含义：代表一个引用类型没有引用指向任何对象。

JAVA垃圾回收机制：  

    JAVA有垃圾回收机制，可以自动回收JAVA中无用的内存。

什么是无用内存？ 

    答：当一个对象没有引用指向时，这个对象就是垃圾。

static关键字:

    static：静态变量（加在成员变量前）；静态方法（加在类方法前）。

    类变量的问题：所有的对象共享其数据，一个对象修改其值，其他对象也相应改变，可以以“类名.变量名”的方式来调用。

类方法：

    不需要创建对象，直接使用“类名.方法名”来调用。静态方法中，只能访问静态的变量，非静态方法两种变量都可以访问。

main方法为什么是static（静态的）？

    答：main方法是程序的入口，在它执行之前不可能有任何对象被创建，JVM需要调用

main方法只能是static的。

package关键字：

    JAVA的包机制：用不同的文件夹来区分不同的类。

    JAVA类的全名： 包名+类名

    import （导包），作用：省略类的

    类名的标准：公司的域名倒过来写（如：com.baidu.国家.……）

JAVA访问修饰符：

    private  （私有）只能类的内部使用

    default  （默认）在同一个包下的所有类之间都可以使用

    protected（保护）两个类不再同一个包，但有继承关系,就可以调用

    public   （公共）到处都可以使用

面向对象的三个特征：
    封装：代码复用；屏蔽细节；

    继承：代码复用；功能上扩展

       在JAVA中使用extends关键字来表示两个类的继承关系，当子类继承了一个父类

       （super class超类、基类）的时候，子类自动拥有父类的所有成员。

       继承（extends）只能是单继承；

       JAVA中使用extends关键字来表示两个类的继承关系，当子类继承了父类

       时super class 超类、基类）的时候，子类自动拥有父类所有的成员。

    多态：动态绑定、池绑定（一个方法有多种形态）。

       多态即是当程序执行的时候，根据传入的参数决定绑定哪个方法。

       条件：

       1有继承；

       2要有父类的引用指向子类的对象；

       3有方法的重写。

方法的重写(override)：

    方法的重写是发生在继承关系中，父类中被重写的方法和子类中重写的方法必须拥 

有相同的方法名，相同的返回值类型，相同的参数列表，子类的重写方法不能有比父类重

写方法更严格的访问修饰符。

方法的重载(overload)：

    发生在同一个类中，重载的方法和被重载的方法必须有相同的方法名，必须拥有不同

的参数列表，返回值类型，可以不同，也可以相同。方法重载根据调用方法的时候传入的

参数决定调用哪个方法。 

super关键字：

      相当于当前父类的的引用。

      每一个子类的对象中都有一个父类的对象，因为子类自动拥有父类的所有对象。

     

      JAVA在构建子类的对象的时候，先构建父类对象，再构建子类对象。

     （1）当子类成员变量与父类成员变量重名时，需要访问父类成员变量时，用super

          关键字调用。      Super.成员变量名

     （2）重写过程中，子类重写方法需要调用父类的重写方法的时候    super.方法名()

     （3）如果父类中没有无参数的构造方法，是不能成功创建子类对象的。需要在子类的构造方法中手动调用父类的构造方法，且必须在第一行。

      解释：

          1.必须先创建父类对象，再创建子类对象；

          2.JAVA是用构造方法来创建对象的；

          3.先调用父类的构造方法，再调用子类的构造方法；

          4.JAVA默认调用的是父类中无参数的构造方法；

          5.给父类提供了一个有参数的显示构造方法，无参的隐式构造方法就不存在了。

对象转型：

      向上转型：父类的引用指向子类的对象（只能用父类的对象）

      相下转型：强制类型转换。

Object类:

      Object是所有类的根类；也就是说，Object类中的所有的方法其他的类都拥有。

toString

     toString()会默认调用的情况：

         1.System.out.println()（控制台上的显示都是字符串）;

         2.出现字符串连接符的时候。

     “==”比较的是栈区的内容，比较两个对象时，必须用equals比较堆区里面的对象。

      JAVA的类，是开发者创建的，我们创建的时候，与这个类相关的比较大小、相等的

  规则也要指定。

      示例代码：

public class Test{

    public static void mian(String args[]){

        Person p1 = new Person("Tom",20)

        Person p2 = new Person("Tom",20)

        System.out.println(p1.equals(p2));

    }

}

class Person{

  String name;

  int age;

    Person(String name,int age){

        this.name = name;

        this.age = age;

    }

    

    public String toString(){

        return "name:" + this.name + "age:" + this.age;

    } 

    

    public boolean equals(Object obj){

        Person p = (Person)obj;

        if(this.name.equals(p.anme)&&this.age==p.age){

            return true;

        }else{

            return false;

        }

    }

}

18 hashCode（哈希码）

      哈希码查找速度最快。

      相等的对象一定具有相等的哈希码（重写过equals方法后，一定要重写hashCode方

  法）。具有相等哈希码的两个对象不一定相等。

19 final关键字

     加在成员变量前，表示这个是常量（常量名称的每个字母都要大写）。

     加在类（方法）前，表示这个类（方法），不能被继承（重写）。

20 abstract关键字

     加在类上，表示这个类是抽象类，不能实例化（instance），即表示不能创建对象。

     如果一个类，就是用来被继承的，如：多态，父类引用指向子类的对象，父类不需要

 实例化，这时可以指定这个类是抽象的。     

     加在方法上，表示这个方法是抽象方法（没有方法体），即表示这个方法是用来被重写

 的。

     注意：有抽象方法的一定是抽象类；而抽象类中可以有非抽象的方法。

21接口（interface）

     接口是一种特殊的抽象类。

     因为其只能拥有抽象方法和常量。

     接口称之为类实现了接口，方法也称之为实现（implements）

     接口之间叫继承，接口之间是可以多继承的。

     接口可以有多个，父类只能有一个，类与接口之间

     示例代码：

public class Test{

    public static void mian(String args[]){

        System.out.println(Car.num);

        Car.run(); 

Car.stop();

Car.a();

Car.b();

    }

}

interface Car extends A,B{

    int num = 10;

    public void run;//可以省略abstract关键字

    public void stop;

}

interface A{

    public void a();

}

interface B{

    public void b();

}

class BMW implements Car,A{

    public void run(){

        System.out.println("BWM is running");

    }

    public void stop(){

        System.out.println("BWM is stop");

    }

    public void a(){

       System.out.println("a");

    }

    public void b(){

       System.out.println("b");

    }

}