java的基础

面向对象
    概念
        面向对象：让创建的new 对象去做事情，只需要反馈结果就可以
        面向过程：所有的事情，都是一步一步的做。
        关键字：this 、super 、 static、final、abstract、interface、package、import
        面对对象的三大特征： 封装性、继承性、多态性
        Java类以及类的成员：属性、方法、构造器、代码块、内部类
    类
        概念
            类（class）是对某一类事物的抽象描述
            对象（Object）用于表示现实中该类事物的个体或实体（instance）：万物皆对象。
类是对象的抽象化，对象是类的具体化。
        设计一个类
            子主题 1
        成员变量
            语法：权限修饰符      数据类型     变量名
        成员方法
            语法：权限修饰符    返回值      标识符（参数）{....方法体....}
            权限修饰符：表示权限的大小，public表示公共的，private 表示私有的。
            返回值
                没有返回值：void
                有返回值：数据类型，并且方法中要有：return    数据类型 ;
            参数（形参）
                语法：
                    没有形参：不写
                    有形参：数据类型    变量名。（多个形参使用逗号隔开）
            方法的重载
                在同一个类中，允许存在一个以上的同名方法，但是他们的参数的个数、数据类型、参数顺序不能相同。
特点：
与返回值类型和权限修饰符无关，只看参数列表，且参数列表必须不同（参数的个数、类型、顺序）
            值传递
                形参：方法在声明时的参数
实参：方法调用时实际传递给形参的值
                    形参时基础数据类型时：将实参基本数据类型变量的“数据值”传递给形参。
形参是引用数据类型时：将实参应用数据类型变量的“地址值”传递给形参。
        
        构造器
            语法： public   类名(形参列表){...字符串...}
如果没有创建构造器，系统默认提供一个无参构造器。
注意：此构造器不是方法，可以称为构造方法，但是和方法不同，其作用是创建对象，不能有除了权限修饰符外的，其他修饰符出现，例如：static  final  等等。
            作用：1、创建对象
              2、初始化对象的属性
            构造器的重载
                当手动输入一个构造器时，默认无参构造器不再存在。
                一个类中可以有多个构造器，但是其形参列表必须不同，也就是必须构成重载。
一个类中至少会有一个构造器，默认或自定义
            属性的赋值：1、默认初始化值
                            2、显示初始化，直接赋值
                            3、构造器赋值
                            4、方法赋值
执行的先后顺序：
       默认初始化>直接赋值>构造器赋值>方法赋值
        代码块
            静态代码块是用来初始化类、对象。代码块如果有修饰的话，只能是static
            代码块
        抽象类
            abstract : 抽象的，可以用来修饰：类和方法，表示抽象类和抽象方法
抽象类语法：public abstract 类名{}
修饰类：抽象类，不能实例化，只能被继承，但是有构造器(便于子类对象实例化时调用)。不一定有抽象方法。
抽象方法语法：public abstract 返回值 标识符();
修饰方法：抽象方法，在子类中必须被重写，否则次子类也要变成抽象类，有抽象方法的类必须是抽象类。
                注意：
        1、抽象方法没有方法体。
        2、抽象类中不一定要有抽象方法，但是有抽象方法的类，必须是抽象类。
        3、子类中必须重写父类中的抽象方法，否则子类也要变成抽象类（父类的父类的...的抽象方法也会被继承）。
    重写
        子类继承了父类中的属性和方法，但是当父元素中的方法，不能满足子类的需求时，就需要在子类中重新定义此方法。这就是重写
        重写的规定：
        1、子类重写的方法：其方法名和形参列表必须和父类中被重写的方法一致
        2、子类重写的方法：其修饰符权限不小于父类被重写方法的权限修饰符
    特殊情况：子类不能重写父类中声明为private权限的方法。
        3、返回值类型：
    父类被重写的方法的返回值类型是void或者基本数据类型是，子类重写此方法时，必须和父类中被重写的方法保持一致
    父类重写的方法的返回值是引用数据类型时，子类重写此方法的返回值可以是此类或者此类的子类
       4、子类重写的方法抛出的异常类型，不大于父类中抛出的异常（学习异常时在具体讲解）
       5、父类中static修饰的方法不能被重写。除非在子类中为重写的方法加上static，就不报错了，但是，此时不再构成重写。
    重写和重载的区别
        重写：不同类中，且存在继承关系。
            1、子类重写的方法：其方法名和形参列表必须和父类中被重写的方法一致
        2、子类重写的方法：其修饰符权限不小于父类被重写方法的权限修饰符
    特殊情况：子类不能重写父类中声明为private权限的方法。
        3、返回值类型：
    父类被重写的方法的返回值类型是void或者基本数据类型是，子类重写此方法时，必须和父类中被重写的方法保持一致
    父类重写的方法的返回值是引用数据类型时，子类重写此方法的返回值可以是此类或者此类的子类
       4、子类重写的方法抛出的异常类型，不大于父类中抛出的异常（学习异常时在具体讲解）
       5、父类中static修饰的方法不能被重写。除非在子类中为重写的方法加上static，就不报错了，但是，此时不再构成重写。
        重载：同一类中
            与返回值、权限修饰符无关，但是方法名字必须相同，并且形参列表必须不同：参数的个数、顺序、数据类型
    匿名对象
        特点：一样是创建了一个对象，只是没有引用或者理解为没有变量来接受这个对象。这就导致，匿名对象只能被调用一次。
实例：new  Teacher().teach("java");
             new Teacher().teach("php");
    封装
        隐藏对象内部的复杂性，只对外提供简单的接口，便于外界访问，从而提高系统的可扩展性、可维护性。
通俗的说：把该暴漏的暴漏，该隐藏的隐藏，这就是封装思想。
或者可以理解为：隐藏类的实现细节，仅对外提供简单的访问方式（接口）。
        封装的体现之一：隐藏属性的实现细节（私有化属性），仅对外提供访问的get 和set方法来获取和设置属性。方法和类也是封装的体现。
    return、break、continue区别
        return:单独使用表示结束方法，后面有返回值表示返回这个值，同时结束方法
        break: 结束循环
        continue:结束当前循环，进入下一次循环
    关键字
        this
            作用：1、在方法内部使用，表示这个方法所属的对象的引用。
2、在构造器中使用，表示该构造器正在初始化对象。
this 表示当前对象，可以调用类的属性、方法和构造器。
在方法内部需要调用此方法的对象时，就用this，具体用法：使用this区分局部变量和全局变量   例：this.age = age;
            在方法中使用：
this 调用属性和方法
在构造器中使用：
this调用构造器必须放在第一行，一个构造器只能调用一个
        super
            super理解为：父类的
可以用来调用父类的：属性、方法、构造器
            1、我们可以在子类的方法或者构造器中，通过使用”super.属性“或“super.方法“的方式，调用父类中声明的属性或方法，但是，通长情况下，我们习惯省略”super.”
2、通过子类对象，调用重写的方法或者属性，会优先在子类中寻找此属性和方法，当在子类中找不到时，回去父类中去找
3、super调用父类的构造器： 必须在构造器中，才能使用“super(形参列表)“的方式，调用父类的构造器，必须写在第一行，和我们学习this时，使用“this(形参列表)” 调用本类中的构造器一样，也就是说：this(形参列表)和super(形参列表)只能出现一个。
在构造器的首行，如果不写 this(形参列表)或者super(形参列表)，那么默认为：super()
            注意：当我们通过子类的构造器创建子类对象时，我们一定会直接或者间接的调用其父类的构造器，进而调用父类的父类构造器，直到 java . lang . Object 中的无参构造为止。虽然调用了父类构造器，但是并没有创建父类对象
        static
              static：静态的
可以用来修饰，属性、方法、代码块、内部类。不可以用来修饰构造方法。
                属性
                    使用static修饰属性：静态变量(类变量)。
属性分为：静态属性和非静态属性。
非静态属性(实例变量)：当我们创建一个个的类实例后，每一个实例都有一套独立的非静态属性。
静态属性(类变量)：与非静态属性相反，所有对象，共享同一个静态属性。
静态变量随着类的加载而加载，
也就是说静态变量的创建，要早于对象的创建。
也就是静态变量可以直接使用 “类名.属性” 的方式调用，也可以使用“对象.属性”的方式调用。
也就是静态变量只会被加载一次，在内存中只会存在一份，存在方法区的静态域中。
                方法
                    使用static修饰方法：静态方法(类方法)。
方法分为：静态方法和非静态方法。
非静态方法(实例方法)：当我们创建一个个的类实例后，每一个实例都有一套独立的非静态方法。
静态方法(类方法)：与非静态方法相反，所有对象(实例)，共享同一个静态方法。
静态方法随着类的加载而加载，
也就是说静态方法的创建，要早于对象的创建。
静态方法可以使用 “类名.类方法()” 的方式调用，也可以使用对象.类方法()。
也就是静态方法只会被加载一次，在内存中只会存在一份。  静态方法只能调用静态的方法和属性
非静态方法中可以调用静态方法和属性。      静态方法中不能使用this、super
            static的用法总结
                何时使用静态属性？
       属性不会随着对象的不同而不同的属性、被所有对象共享的属性可以被声明为静态的。
何时使用静态方法？
       当方法操作静态属性时、工具类中的方法，都习惯上写成静态方法。
        final
            final—表示最终的
                修饰类：表示该类不能被继承的
修饰方法：表示该方法不能被重写。
修饰属性(全局变量)：变成：常量(全部大写)，不能被修改(重新赋值)，必须赋值。
方法中不能对常量进行赋值，因为常量在对象创建完成之前，必须完成初始化，方法是在对象创建完成之后才能调用所以方法中不能对其进行赋值。
    JavaBean
        Javabear是一种Java语音写成的可重用的组件JavaBean是指符合以下标准的Java类
            类是公开的
            有一个公共的无参构造器
            有属性，且对外提供get和set方法
    继承
        子类继承父类中的所有属性和方法
        一个父类可以有多个子类，但是一个子类只能有一个父类：亲爹只能有一个啊！！！
当然子类也可以被继承
           Java中的每一个类(自定义类，核心类、工具类等等)，都直接或者间接的继承自 java.lang.Object，这就说明，java中所有的类都具有java.lang.Object类中声明的功能 
注意：是java.lang.Object不是Object，因为Object类是可以自定义的。
    权限修饰符
        Java的四种权限修饰符：private、缺省( default ) 、protected 、public。写在类的成员定义之前，用来限定对象对该类成员的访问权限
             对于class的修饰只能使用public 或者 默认
  public表示整个工程中都能被访问
  缺省表示同一个包下可以被访问
    多态
        同一事物或者对象，不同的形态，这就是多态性。
简单的说:就是用基类的引用指向子类的对象(父类的引用指向子类的对象)。
        虚拟方法的调用：具备多态性之后，在编译时期，只能调用父类中的方法，在运行时期，实际执行的是子类重写之后的方法。子类中的方法是获取不到的。所以：编译看左边，运行看右边。
        多态使用的前提条件：
         1、有继承关系
         2、有方法的重写
         3、向上转型：父类引用指向子类对象，只有这样该引用才既能调用父类的方法，又能调用子类的方法
        应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 
派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用
        多态不适用于属性。方法的重载不是多态。因为重载，是在，编译时期就和类实现了静态绑定，而多态是：动态绑定，就是在运行时期才和类实现绑定。只有动态绑定才是多态。
对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定. 绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。
    equals和==的区别
        ==可以比较基本数据类型和引用数据类型，基本数据类型比较的是：值，引用数据类型：比较的是地址值。
equals方法：比较两个对象是否相等，只能用来比较引用数据类型：比较的是内容，实体中相应的属性，当然前提条件是equals方法被重写，如果不被重写其比较的还是地址和==相同。
    单例模式
        饿汉式：
    好处： 线程安全的。
   坏处：对象加载时间过长就是生命周期过长，随着类的加载而加载，类的消失而消失。
        懒汉式：
   好处：延迟对象的加载。
   坏处：线程不安全的。想要将其变呈现成安全的，在学习过线程之后就可做到。
    属性赋值
        默认值初始化
显示初始化
构造器中初始化
创建对象，使用对象.属性、对象.方法();
在代码块中赋值
先后顺序：
       默认初始化>显示初始化 | 代码块中赋值 > 构造器中赋值 > 创建对象后赋值
    接口-interface
        java不支持多重继承，有了接口，就可以
得到多重继承的效果
继承是一个是不是的关系，而接口“是一
个能不能“的关系。
接口的本质是契约、标准、规范，
类是单继承，接口是多实现。
            注意：
       1、接口中不能定义构造器，也就是接口不能被实例化。
       2、java中，接口是用来被类实现(implements)的。
       3、如果一个类想要实现一个接口，那么此类必须重写接口中的所有抽象方法，否则此类要变成抽象类。
       4、一个类可以实现(implements)多个接口。(弥补了单继承的局限性)。
       5、接口的使用，就是多态的一种体现。

                除了以上内容外，新增：静态方法、和默认方法。
        静态方法：只能使用：接口.方法();的方式调用。
        默认方法：使用 default 修饰，可以使用实现类对象来调用，默认方法可以被实现类重写
注意：
        1、如果子类（实现类），继承的父类和实现的接口中声明了同名同参数的默认方法，并且子类在没有重写此方法时，默认调用父类中的方法。—类优先原则，重写了就调用重写的方法
         2、实现类，实现的多个接口中具有同名同参数的默认方法，此时如果不重写此方法的话，会报错。
    内部类
        在java中，允许一个类的定义的内部定义另一个类，前者称为外部类，后者称为内部类。
内部类的名字不能和外部类的名字相同。
内部类分类：
            成员内部类：分为，static修饰成员内部类和非static修饰的成员内部类
            局部内部类：方法内部(开发中很少使用，源码中经常见到)、代码块内部(没见过)、构造器内部(没见过) 
            成员内部类：
       作为外部类的成员
    调用外部类的结构
    可以使用static修饰
    可以被4种权限修饰符修饰
        作为一个类：
    可以有自己的属性、方法、构造器等
    可以被final修饰，表示不能被继承，反之，可以被继承。
    可以被abstract修饰，表示不能被实例化。