1.类和对象

       a. 对象:(万事万物皆可为对象)

                所谓的对象就是由一个抽象的到具体某些属性的一个形式,即通过new一个实例化的类,封装一些特有的属性

       b. 类:就是指抽象,看不见摸不到的东西

        一般情况下创建对象的语法:(也可以通过反射创建)

                类名 对象名 = new 类名();        //通过构造方法创建

2.构造方法

        构造方法是一个与类同名且没有返回值类型(连void也没有)的方法。默认情况下会有一个无参构造方法,但是一旦定义了有参构造,则系统默认的无参将会失效。

        作用:用来创建当前类的实例化对象,并对初始化其成员变量

        语法:        修饰符 类名(参数列表){方法体}

3.关键词this

        this关键词代表当前对象的引用,即谁调用,谁就是this。

public class This_01 {

    public static void main(String[] args) {

        This_01 t = new This_01();
        System.out.println(t);//输出t的地址

        This_01 s = t.m1();//由于m1()方法中返回this,所以s也是t的引用
        System.out.println(s);//此时s输出的地址仍为t的地址
    }

    public This_01 m1() {
        System.out.println(this);//这里的this,是因为t.m1()调用,所以this是指向t的
        return this;
    }
   
}

        用法:this用在成员方法中和构造方法中,均是为了区分同名的成员变量和局部变量

4.关键字static

        作用:在有static修饰的属性和方法中,方便可以在没有new实例化对象的情况下,通过类名.属性或方法来进行调用

        static可以修饰:a.静态变量        b.静态方法        c.静态代码段

                静态代码段:

    /**
     * 在类加载的时候(即访问一个类的静态属性时)才会执行,并且只执行一次,在构造方法前执行
     */
    static {
        // java代码
    }

5.面向对象的三大特性:        封装、继承、多态

        a.封装:把对象的所有组成成分写在同一个类中,再使用访问修饰符将数据隐藏起来,控制其他用户对该类的访问权限,增强代码的安全性

                访问修饰符:有高到底

    public int a;//public 所有地方都可以访问到
    protected int b;//protected 属于继承权限,在同包、同类、子类中 可以访问到
    int c;//不写即默认,默认为包权限,在同包,同类下可以访问,其他都不行
    private int d;//private 除了当前类中,其他哪里也不行

        b.继承:从已经抽象好的类中派生出新的类,新类既包含已有类的属性和方法,也可以再扩展新的属性和方法

                继承的特点:

                        1):单继承,多实现。即一个类只能继承一个父类,可以实现对个接口

                        2):有private修饰的成员变量或方法不能被子类继承

                语法:

[修饰符] class 子类 extends 父类{
    //类体
}

              关键字super:

                        1):用在子类的成员方法中,用来区分子类和父类同名的成员方法/变量

                        2):用在子类的构造方法中,依旧可以用来区分子,父类的同名方法/变量,如果是用来调用父类的构造方法时,super(参数);必须放在子类构造方法的第一行 

                @Override(覆写):前提是在extends继承体系下,父类无法满足子类的需求时,才会发生覆写

                关键字final:可以修饰类、变量、成员方法

                        类:不能被继承(终结类)

                        成员方法:不能别覆写

                        变量:在整个程序的生命周期内,不能进行二次赋值,并且如果是成员变量没有默认值

                运算符instanceof:

        A b = new A();
        if (b instanceof A) {// 判断b是否是由A实例化来的,返回值是boolean

        }

        c.多态:        父类 变量名 = new 子类();

                多态的前提条件:在继承关系的体系中

                多态的体现形式:

                        1).变量(成员/局部):用父类进行声明,子类对象用来赋值

                        2).实参/形参:参数列表使用父类声明变量,方法调用时传入子类对象

                        3).返回值:返回值类型使用父类声明,return的时候 返回子类对象

Animal dog;//用父类类型声明一个dog变量,    不是多态
dog=new Animal();//父类引用指向父类对象    不是多态
dog=new Dog();//父类引用指向子类对象       是多态

                多态的特点:

                        1).父类没有,子类无论有没有,都无法进行访问

                        2).父类有成员方法,子类也有相同的成员方法,则执行子类的(发生覆写)

                        3).父类有成员方法,子类没有成员方法,则执行父类的

6.Object类:所有类的祖宗类,即如果一个类没有继承另一个类,该类就默认继承Object

        equals()方法:默认比较两个对象的内存地址,也可以根据自己的需求进行覆写

        toString()方法:返回对象的字符串表示形式

7.抽象类:使用abstract修饰的类

        语法:

修饰符 abstract class 类名{
    [修饰符] abstract 返回值类型 方法名();
}

                1).含有抽象方法的类,一定是抽象类(反之不对);抽象类必须被继承,抽象方法的实现就是去掉abstract并加上方法体,如果父类的抽象方法没有被全部实现,那么这个子类,也需要是抽象类

                2).抽象类中可以有抽象方法也可以全部都是普通方法(包括实例方法、静态方法)，在抽象类中可以定义实例成员属性、静态成员属性，还可以书写构造方法

                3)抽象类不能被实例化,即不能new 对象

                4)abstract和final不能同时修饰一个类

8.接口:一个接口只有方法的声明没有方法的实现

        语法:

修饰符 interface 接口名{
    修饰符 static final 数据类型 变量名=值;
    修饰符 abstract 返回值类型 类名(参数);
}

                1).接口中的方法必须全用public abstract修饰,成员变量必须用public static final修饰

                2).接口中不能有普通方法和构造方法

        接口与接口之间:多继承,用逗号隔开        extends xxx,xxxx

        类与接口:通过implements 多实现        implements xxx,xxxx

                注:一个抽象类实现接口,可以实现 0~n个抽象方法;一个非抽象类实现接口,需要实现所有的抽象方法