DAY5面向对象

面向对象：是框架（宏观把握，整体分析），面向过程：是流程（微观操作）。本质：以类的方式组织代码，以对象的方式封装数据。 继承、封装、多态

类是抽象的，对象是具体的

回顾：方法

方法都要return，并且后面不能再写语句，如果返回void，可以return；结束

静态方法不能直接调用非静态方法，因为静态方法是和类同时创建，而非静态方法需要实例化之后才能使用

值传递：不能直接改变类下面的属性，形参和属性a在不同的内存

引用传递：可以调用方法，改变对象的属性。对象.name在同一个内存（实际是操作堆里的地址）。

public class Demo01 {
   static int b;
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo01.change(a);

        System.out.println(b);
    }
    public static void change(int a){
        int b = 10;       //作者用的是a，我用的时候会显示已经定义过？不知道为什么
    }
}

public class Demo02 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo02.change(person);//注意：这里使用Demo02来调
        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name="张三";
    }

static class Person{
        String name;
    }
}

一个类里有且只有 属性 方法；两部分构成

this代表当前这个类

学程序好？可以对世界上的事物进行建模！

构造方法：1、必须和类的名字相同，2、必须没有返回值

新建一个类，class文件会自动添加一个构造方法；类运行先运行构造方法（构造器）；

1、new对象本质是在调用无参构造器（如果自己定义了一个有参构造，那么也得留一个无参构造，用作new对象用），

2、构造器用于初始化值

Alt+insert  添加generator，构造器、get/set**快捷键

对象封装：高内聚（内部细节由自己来完成，封装起来不允许其他人干涉 private）、低耦合（暴露少量的方法供外部调用get set）

属性私有 private

get/set

1、提高安全性，保护数据  2、隐藏代码的实现细节  3、统一接口  4、系统可维护性增加

 

继承：extends，继承是类和类之间的关系

子类不能继承父类的私有属性或方法（属性私有，留get/set方法pubulic接口给子类调用）

在JAVA中，所有的类都直接或间接的继承Object类。

public class Student extends Person{
    private String name = "lisi";

    public void test(String name){
        System.out.println(name);//调用形参变量
        System.out.println(this.name);//调用类的属性
        System.out.println(super.name);//调用父类属性

public void test2(){
    print();//调用本类
    this.print();//调用本类
    super.print();//调用父类
}

调用父类的构造器super（）；必须放在子类代码的第一行，否则会报错；super和this不能同时调用构造方法，因为都得放在第一行。

this：本身调用这个对象 ，没有继承也可以使用，本类的构造

super：代表父类对象的引用，只能在继承条件下才能使用，父类的构造

方法的重写@override（都是方法的重写，和属性无关）：

静态方法只和左边有关，

A a = new a();    结果 ' a.test()'

B b = new a();    结果'b.test()'

非静态方法：重写（需要有继承关系，方法名必须相同，参数列表也相同，修饰符范围可以扩大不能缩小）

多态：

Student    extends   Person 

Student s1 = new Student();

Person s2 = new Student();

对象能执行哪些方法主要看左边的类型，和右边关系不大（左边会执行右边重写后的方法）！

s1、s2都会执行 student的run（）方法（Person也有run方法，但是s2不执行）；

1、s2不能调用Student独有的方法，如果要调用就得向下强制转型

Person obj = new Student（）；

（（Student）obj）.go    ；//go方法是Student独有的，所有需要强转才能使用

2、低转高不需要强转，但是有可能会丢失子类的一些独有方法。

1、多态是方法的多态，属性没有多态；

2、父类和子类，转换要有继承关系，否则ClassCastException！类型转换异常。高转低需要强转

3、多态存在的条件：要有继承关系，方法需要重写，父类引用指向子类的对象 Father f1 = new Son（）；

static方法属于类、final、private都不可以重写。 如果一个类被final修饰了，那么也不能被继承

instance of 判断是否存在父子关系

son instance of Father（前面是对象，后面是类）   ;     ture

七、static  （属性、方法） 和类一起加载，可以被类直接调用，main方法可以直接调用static方法或属性，无法调用非static的，因为main方法本身就是static方法

public class Demo03 {
    static{
        System.out.println("静态代码块，第一执行");//静态代码块类加载时只执行一次
    }
    {
        System.out.println("匿名代码块，第二执行");//创建对象时执行
    }
    public Demo03(){
        System.out.println("构造方法，第三执行");//创建对象时执行
    }

    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
    }
}

八、抽象类  abstract   

抽象类的所有方法必须由子类实现。就像一个插座，插什么东西子类来实现，抽象类不能new

抽象类里可以写普通方法，但是如果类中有抽象方法，必须是抽象类

九、接口  interface，  implements实现接口

只有方法，没法实现，接口本质是契约。接口都是public、abstract的。

十、内部类（选修）：在一类类中再定义一个类  Outer outer = new Outer();   out.Inner inner = out.new Inner();

内部类可以获得外部类的私有方法、属性、

一个java文件中，可以有多个class类文件，但只能有一个是public的

new.Cat（）.eat   没有初始化名字（Cat cat = new Cat()，这种是初始化了名字），这种叫做匿名内部类