一、编程思想　

    1、面向过程

        面向过程：关注的是过程——步骤。

        站在一个执行者的角度考虑问题，做事情。

    2、面向对象

        面相对向：关注的是对象——。

        站在一个指挥者的角度。

        是一种编程思想，不是一种编程语言。

        如何使用面向对象的思维方式思考问题？

            A：思考问题域中涉及到了哪些对象。

            B：设计这些对象。(构建类)

            C：对象和对象之间的关系。

    继承关系：is - a

    实现关系：实现类，实现接口。

    依赖关系：一个类作为另一个类的方法的参数。

    关联关系：一个类作为另一个类的属性。

二、类和对象【重点】

    2.1 类

        概念：类，就是类别。同一类事物的抽象描述。

        - 类的属性：成员变量，描述类的外部的特征的。选"名词"。

        - 类的功能：成员方法，描述类的行为功能的。选"动词"。

        示例代码：

            publicclassPerson{

                Stringname;

                    intage;

                publicvoideat(){

            }

    }

2.2 对象

    概念：类中的一个具体的实例。

        - 对象就是可以访问类中的数据：赋值，取值

        - 对象还可以执行类中的方法：将方法进行调用。

2.3 实例化一个对象

        就是通过调用类的构造方法，进行创建对象，就得到了该类的实例。

            Personp1=newPerson();

            类和对象的关系：

        将类进行实例化，就得到了对象。

        如果将所有的对象的共同特征，进行抽取，然后加以描述。就是构建这个类。

2.4 构造方法

        构造方法，又叫构造器，构造函数。Constructor。

        就是一个特殊的方法。

            1、作用：专门用于创建对象的。

            2、声明：要区别于普通的方法。

                修饰符：只允许访问权限修饰符。

                返回值：没有，不能写void。

                方法名：必须和类名一致。

                参数列表：无参，有参

        3、调用：必须通过new关键字来调用，开辟内存，创建对象。

    注意点：

        如果一个类中，没有显示的构造方法，那么由编译器自动添加一个，无参构造方法。

        如果类中，有了自己写的构造方法，那么编译器不会再给添加任何的构造方法。

示例代码：

        publicclassPerson{

            Stringname;

            intage;

            publicvoidPerson(){}

            publicvoidPerson(Stringname,intage){}

               publicvoideat(){

             }

            }

编码习惯：

私有化属性

提供getter和setter方法

添加无参构造，和有参构造。

2.5 匿名对象

    只有对象的创建，没有对象的声明。就是没有名字的对象：就是没有一个引用持有它的地址。

        //正常的对象：=左边做对象的声明，就是个引用， =右边在创建对象，创建完对象之后，会将对象的内存地址给p1。p1叫做引用，叫做对象。

    Personp1=newPerson();//引用类型

    //匿名对象：

        newPerson().eat();

    "一次性的"。随着对象的创建而使用一次。

三、面向对象的三大特征

    3.1 封装性

        3.1.1 概念

            概念："打包"的概念。保护数据安全。隐藏类的实现细节，对外提供统一的操作。

        体现：

            1、类的封装。

            2、方法的封装。

            3、属性的封装

                step1：使用private修饰属性，限于本类中使用

                step2：提供getter和setter方法，用于给属性赋值和取值。

                    注意点：boolean类型，isXXX();

    3.1.2 访问权限修饰符

        1、private：限于类的内部能够访问

        2、默认的：啥都不写就是默认的(缺省),限于同包下能够访问

        3、protected：受保护的，限于同包下能够访问，不同包需要子类中才能够使用。

        4、public：公共的， 没有限制。

    示例代码：

        publicclassPerson{

            privateStringname;

            privateintage;

        publicvoidsetName(Stringname){//就近原则

            this.name=name;

           }

        publicvoideat(){

            System.out.println(name+"，吃东西啦。。");

        }

    }

    3.1.3 this关键字

        词义：这个，

        用法一：指代本类的对象。

            可以访问本类的属性和方法。在本类中使用的时候，this可以省略。编译器会自动添加。

            但是，当局部变量名和成员变量，命名冲突时，可以使用this来进行区分。

        用法二：指代本类的构造方法。

            this()，就表示构造方法。当前类的。

            如果类中有多个构造方法，那么靠参数来区分：this()-->无参构造，this(参数)-->有参构造要位于首行。

    3.2 继承性

        3.2.1 概念

        概念：描述两个类的关系。一个类(子类)继承了另一个类(父类)。

            满足 子类 is - a 父类 范式，两个类才可以使用继承。

                父类：基类，超类，SuperClass

                子类：派生类，SubClass

        - 子类中可以直接访问父类的非私有化的属性和方法。

        - 子类可以新增自己的属性和方法。

        - 子类还可以重写父类的方法。

    3.2.2 作用

        1、降低程序的冗余，避免重复的代码。

        2、子类扩展父类的功能。

        3、模拟现实世界的关系。

    3.2.3 关键字

        extends：词义，扩展

        classSuperClass{}​

    classSubClassextendsSuperClass{}

    3.2.4 继承的局限

        Java中只支持单继承：一个类只能有一个父类。

        但是允许多层继承：爷爷-爸爸-孙子

    3.2.5 子类对象的创建过程

        先执行父类的构造方法：开辟父类中属性

        再执行子类的构造方法：

          意味着：子类的构造方法，第一行一定是调用了父类的构造方法。默认调用父类的无参构造方法。如果子类的构造方法，没有显示的调用父类的构造方法， 那么由编译器自动添加super()，表示调用父类的无参构造。3.2.6 

    super关键字

        可以直接访问父类的属性和方法。

        指代父类的构造方法。有参，无参。位于首行。

        注意和this关键字的对比。

    3.2.7 方法重写：override

        概念：继承中，子类将父类已有的方法，重新实现。(重新提供一个方法体)​

    规则：

        1、继承结构中

        2、重写方法声明必须和父类的一致：返回值类型，方法名，参数列表。

        3、访问权限，不能比父类更加严格：private-默认的-protected-public

        4、重写方法不能抛出比父类更大的异常。

3.3 多态性

    3.3.1 概念

        概念：事物的多种形态。

    3.3.2 方法的多态

        方法的多态：一个方法的多种形态--->方法的重载(overload)。

        概念：同一个功能方法，根据参数不同，执行的具体的方法也不同。

    classA{

            publicvoidadd(inti,intj){//1

        }

    publicvoidadd(doubled1,doubled2){//2

       }

    }

    规则：

        1、同一个类中

        2、方法名必须一致。

        3、参数列表必须不同：顺序，类型，个数。

            对象的多态：结合方法的重写。

    3.3.3 对象的多态&方法的重写

        子类对象的向上转型和向下转型。

        父类：Animal，子类：Cat，Dog

    classAniaml{

        Stringname;

        intage;

        publicvoideat(){}

        publicvoidsleep(){}

    }

    classCat{

        Stringcolor;

        @override

        publicvoideat(){

        }

    //新增

        publicvoidcatchMouse(){

       }

    }

    1、向上转型：子类对象向上转型后，会失去子类新增。可以访问的是父类的属性和方法，以及子类重写。

    2、向下转型：以向上转型为前提，将子类对象，由父类类型，再转为子类类型。可以重新获访问子类新增。

    继承结构中，子类是一个特殊的父类类型。

​

    父类类型，指向一个父类对象。

    Animala1=newAniaml();

    也可以指向一个子类对象。子类对象的向上转型。

    Animala2=newCat();//向上转型，name，age，重写eat()，sleep()

    Catc1=newCat();​

    Catc2=(Cat)a2;//向下转型,name,age,color,重写eat()，sleep()，catchMouse()

instanceof关键字：

    来判断某个引用指向的对象，是否属于某个类(包含父类)。

    向下转型前：先使用instanceof关键字，判断是否是该类型，否则会失败：ClassCastException

    语法：

    引用instanceof类名

    --->boolean的结果：true，false

    Animala1=newAnimal();

    Catc1=newCat();

    a1instanceofAnimal--->true

    c1instanceofCat--->true

    c1instanceofAnimal--->true

    a1instanceofCat--->false

    3、结合方法的重写

    总结：

        如果想知道一个引用，能够访问哪些？看=左边是什么类型的。

        如果=左边声明的是父类类型，那么就调用父类中声明。

        如果=左边声明的是子类子类，那么就调用父类中的，以及子类新增的。

        如果想知道一个引用，执行的方法是否重载？看=右边真正创建的是哪个对象

        如果=右边创建的是父类对象，那么调用父类中。

        如果=右边创建的是子类对象，那么调用子类重写的方法。

    对象多态性结合方法的重写：如何体现多态的？

        Animal a1 = new Aniaml();//调用父类的方法，不是子重写的。

        Animal a2 = new Cat();//调用父类中声明的，但是是子类重写的方法。

        a1,a2---->Animal

        根据new的对象不同，可能调用重写的(子类对象)，也可能调用不重写(父类对象)。

    4、对象多态性的应用

        将父类的类型作为参数，可以传入任意的子类对象。传参：向上转型。

        将父类的类型作为返回值，可以返回任意的子类对象。

        publicstaticvoidtest(Animala){

    }

​        publicAnimalgetAnimal(){

        //......

        returnnewCat();

    }

    publicstaticvoidmain(String[]args){

    Animala1=newAnimal();

        test(a1);

test(c1);

}

​

四、static，final、abstract关键字

    4.1 static关键字

            含义："静态的"，属于类。由类直接访问。

    4.1.1 静态属性

            由static修饰的成员变量，就表示为静态成员。也叫做静态属性。属于类，只有一份。在内存中另一块空间。多个对象也可以访问，共享这一份数据。

        静态属性，随着类的加载而产生。成员变量，随着对象的创建而产生。几个对象，就几份独立的成员变量的数据。

        应用：类的所有的对象的某个属性值都相同，就可以设计为static的。节省内存，操作便捷。

    4.1.2 静态方法

        由static修饰的方法，就叫做静态方法。由类直接调用。对象也可以调用，但是不建议。

        静态方法：可以有静态的属性以及调用其他的静态方法。

        静态方法：不能直接访问非静态的属性和方法，以及不能出现this和super关键字。

        应用：如果一个方法中不涉及对象的内容，就可以设计为静态方法。由类直接调用，不需要创建对象。比较简洁。

        工具类：往往都是静态方法，由类直接调用。

    4.1.3 代码块{}

        局部代码块：

        也叫普通代码块。就是方法中的一块代码。if，for，while。。。{}

        注意作用域

            构造代码块：

                    类里，方法外的代码块。

                    当创建对象，随着构造方法的执行而执行。优先于构造方法执行。创建几个对象，就执行几次构造代码块以及构造方法。

                        可以统一初始化非静态的属性

            静态代码块：

                    使用static修饰的代码块

                    当程序加载的时候执行，优先于main执行，只执行1次

                    如果有些代码在项目启动的时候就执行，可以写在static代码块中。

            同步代码块：

                    多线程

    4.2 final关键字

            词义："最终的，最后的"

             修饰变量——>不允许在修改值。常量：所有的字母都大写。

            局部变量

            成员变量

            修饰方法——>不允许子类重写

            修饰类——>不允许子类继承

    4.3 abstract关键字

        含义："抽象的"

        修饰方法：抽象方法

        该方法只有方法的声明(功能描述)，没有方法体，{}也没有，直接；结束了。

        目的：将功能的声明和实现分离开。强制子类必须重写

            所在的类，必须是抽象的。

            修饰类：抽象类——>"做爸爸"

            不能被实例化，也就是说不能创建对象

            抽象类中可能包含有抽象方法。

            必须等待子类来继承，并且实现所有的抽象方法。才允许创建子类对象

            如果子类没有实现全部的抽象方法，那么子类也是抽象的，要再等子类继承并实现抽象方法。

            抽象类：作为父类。用于继承。

            抽象类：成员变量，常量，静态成员变量，成员方法，静态方法，构造方法，final方法，抽象方法。。。

            抽象方法所在的类，必须抽。

            抽象类中不一定非要包含抽象方法。

五、接口

    5.1 概念

        接口就是一个协议，一种规则，一个标准，一个功能声明。

            USB，Type-C。。。。

    5.2 接口的语法

        //声明一个接口

        interfaceA{

                //静态常量

                //抽象方法

        }

​

        //接口更不允许实例化，需要有实现类来实现接口中的方法。

        classA1implementsA{

        //此处实现接口A中的所有抽象方法。

    }

        接口中：

            静态常量：默认的修饰符，public static final

            抽象方法：默认的修饰符：public abstract

5.3 接口的使用

        多实现：一个实现类，可以同时实现多个接口，就意味着同时满足多个规则。

        多继承：一个接口可以继承另一个接口，而且可以同时继承多个接口。

        类只允许单继承，但是接口可以多继承。因为接口中的方法，都是抽象的，没有具体的实现。

        一个类，如果没有实现接口中的所有的方法， 那么该类是抽象的。

        一个类，可以继承父类的同时，实现其他的接口。

        特殊方法：

           static方法，允许有方法体，由接口名直接调用。

            JDK1.8版，新增的功能：default方法：允许方法有方法体。提供基本的功能，不强制实现类必须实现。

5.4 接口的作用

        降低了程序耦合性：功能的声明和功能的实现分离开。面向接口编程。

        定义的都是规则，都是抽象方法。保持了接口的一致。

        接口可以多继承，使用起来更灵活，弥补了java单继承的局限性。

5.5. 接口回调

    一个接口A，和它的实现类，在另一个类B中，持有了接口A的引用，调用接口中的方法，就是接口回调。

二、匿名内部类

    匿名内部类：没有名字的内部的类。

    前提：接口或继承父类。

    直接new匿名内部类的对象

        interfaceA{

            publicvoidtest();

        }

​

        //A a = new 实现类对象；

        Aa=newA(){//从此处开始，就是匿名的呢不累

                publicvoidtest();

            };//到此处结束

        a.test();

一般匿名内部类适合：使用一次，创建一次对象。

匿名内部类：编译之后产生字节码文件：

内部类的字节码文件名的规则：先写外部类名，然后$，然后是内部类的名

外部类$1.class

外部类$2.class

....

2.3、Object类

    Java中所有的类，都是以继承结构存在的。

    Object类是所有类的基类。所以只要是Java中的类的对象，默认都可以执行Object类中的方法。

    java.lang这个包下的类，在使用的时候，无需导入。其他的包下的类，需要导包。

    importjava.util.Scanner;

    importjava.util.Arrays;​

    java.lang.Object

    java.lang.String

    1、getClass()-->Class

    获取一个引用指向的对象，是哪个类型的。返回值类型，目前超纲。

    想判断两个对象是否是同一个类型：obj1.getClass()==obj2.getClass()