面向对象基础小结

Posted 2021-03-04 macro-renzhansheng

拨

1.量化：我们最终是要对一个事物进行量化。
     连续型：一个连续的值，数不过来
     离散型：一个可以数的过来的值
    
2.分类的过程
     1）属性（特征）：状态信息
     2）方法（行为）：无法量化的一个过程

3.类：一个抽象的概念，是对事物的划分，不是具体的东西。
     类是具有相同属性和方法的一组对象的集合。
     类是对象的抽象，对象是类的具体。
4.对象：一个实实在在存在的东西，是一个你看得见摸得着的东西，是一个你能指名道姓的东西，是一个一说你就知道具体是什么的东西。
    
5.从编程角度来讲：
     类：是一个文件
         一个.java文件
         用class来声明类
         类的首字母必须大写
     对象：程序中的一个数据
         对象也是一种变量，叫引用类型变量
         对象的声明过程，完全符合一般变量的声明过程。【new +构造（）：真正的对象】
       

程序中区分不同的个体，或者如何描述个体的特征：
     属性：对象具有的各种特征，静态的。
     方法：描述对象执行的操作。动态的。
     --由一组属性和方法构成，描述客观存在的一个“实体”（对象）
     --具有相同属性和方法的一组对象的集合，类是对象的抽象化描述，对象是类的具体实例。（类）
    
对象和类是面向对象编程的核心。
     -所有的java程序都是以类class为组织单元，一个Java文件就是一个类。
     真正执行程序时通过类的具体化对象来完成的。
    
方法调用注意：
     基本数据类型传递变量的值
     引用数据类型传递是地址

结构化开发：面向过程
     面向功能划分的软件结构
     从上到下，按步执行
     最小的粒度是方法
     步骤繁琐，制约了软件的可维护性和可扩展性
     代码一次成型，后续修改非常麻烦
    
面向对象开发
     把软件系统看成各种对象的集合
     系统结构稳定
     子系统相对独立
     软件较好的可维护性，可扩展性强
    
面向过程编程：
     关注点在于每一个细节，每一步的具体操作。
面向对象：
     关注点在于整个事件的参与对象，将系统中的参与者全部看成模块化的对象。
    
面向对象程序设计：OOP
     编程思想，思维模式：将程序中的所有参与者模块化为对象，然后通过各种对象之间的相互作用关系来完成程序的需求。
类：对象的模板，抽象化的对象    如：Scanner工具类
对象：类的具体实例化

方法：
        void：关键字
        有值：声明一个类型
        如果返回值不是void，那么在方法当中，必须执行一次，也之恩那个执行一次return
         return执行之后，后面的代码会报错！

1. 修饰符 返回值类型 方法名（形参列表）{方法体}
         形参列表：形参是指，传递给方法的参数类型。
         实参：调用的时候，具体传递值。
         参数传递:
             实参和形参的个数要对应
             类型位置要一一对应
             形参属于局部变量
        
         ***不定长参数：
             形参的定义方式：类型 ... 变量名
             实参的传递：类型统一，个数随意（0-n）
             不定长参数处理，当成一个数组处理。
             一个参数列表中，不定长参数只能有一个，而且只能放最后
             一般来说：不定长参数用的不多。--Java中没有默认值！
     2.地址传参******
         什么是地址？           
             实例化对象后————new()，就是新的对象。
             如果是对象之间的赋值，那么赋值的是堆内存的地址。
             在使用引用数据类型之前，请务必做好空值判断。
         引用传参
            
     3.构造方法：
         1.构造方法：描述一个对象的生成过程
         2.虚拟机默认会添加无参构造；如果显示声明过，则会覆盖。

     4.无论是构造方法，还是普通方法，都可以重载。
        
         在方法当中，直接调用变量名，优先取局部变量！
    
    This关键字：-->计算机组成等等底层的重要性！
         这方面未来有希望！！！（突破基础理论+应用）
       
         this:当前对象本身
             --理解：this.wait()
                   this.notifyAll()
         this()只能写在第一行————只能调用一次构造。
     作用域：
         1.代码块：写在一对花括号中间的。
         2.Java的作用域，叫块级作用域
         3.成员变量：直接卸载类当中，也叫：全局变量，处于犬奴作用域当中。
         4.局部变量：在方法当中（包括构造函数，静态代码块中）
         5.里面可以调用外面的，外面不可以调用里面的，平级之间按相互不干扰。
         6.成员变量会有初值：参考数组
         7.局部变量没有初值,必须初始化！！！
         8.局部变量不可以有访问修饰符*****
         9.局部变量的优先级是高于全局变量的
        

封装

封装：将类的某些信息隐藏在类的内部，不允许外部程序直接访问；
         外部只能通过该类提供的特定方法来实现对隐藏信息的操作和访问。
         如何实现封装：
             1.修改属性的访问权限，设置为private（私有）
             2.创建共有public的getter和setter方法
                 getter：让外部来获取属性的方法
                 setter：让外部来修改属性的方法
             3.setter方法中加入属性控制语句，以确保属性的正确性和合理性。

static修饰符：静态修饰符
         1.成员变量——静态变量，通过类名直接调用
         2.成员方法——静态方法，通过类名直接调用
         3.代码块：写在类中，方法之外，并且用{}包裹起来的一段代码。
             当程序中访问该类时，自动执行代码块中的语句。
         JVM加载该类时，执行该代码块，只执行一次。
        
         --用static修饰的成员变量也叫做类变量，表示该变量不再属于某个对象，而是属于该类，所有的对象共享该属性。（内存中只有一份）
         实例变量——不用static修饰
        
     静态方法：
         1.不能访问非静态方法、属性
         2.不能使用this关键字（实例化对象）

    ---静态关键字描述的是一种共有的信息，不属于任何一个实例对象，属于类，被所有的实例对象所共用。
     类的构造函数：给成员变量赋值，初始化
     类的静态代码块：给静态变量赋值   

继承

protected：同包 和 子类可见
不写（默认的）：同包可见
private：同类可见

-最终类，不可被继承
-最终方法，不可被重写

继承：子类对父类的继承
     父类：
     子类：使用extends继承父类，除了私有和父类构造以外的所有成员。

单根继承原则：每个类，只能有一个直接的父类。

this：对象本身
super：代表父类对象（包含 继承链上的所有）对象
     -super可以调用父类的构造、属性和方法。
    
     1.默认情况下，子类构造将默认调用父类的空参构造 。
     2.如果父类没有空参构造，则子类需指定（显示）调用某个构造。
     -如果不在同一个包里，默认的成员则无法继承，但是可以继承protected的成员；
     -如果在同一个包里，则除了私有以外，都可以继承。
    
     3.使用this和super可以用来区分：父类和子类当中的成员。
         如果该成员是继承来的，那么也可以使用this来调用。
     4.为了防止父类和子类属性之间的相互污染。【属性】
    
     5.如果说，在子类当中不满足父类的某个方法，需要对该方法进行修改或补充，那么可以通过方法重写来实现。
         -当子类重写了父类的某个方法后，子类调用重写后的方法；父类调用原本的方法。
         -当父类当中有某个成员方法被多次重写，那么子类优先调用最近的那个！
        
         -构造方法不能被重写
         -重写可以理解为“覆盖”
          --访问权限不能严于父类。
          --返回值和父类相同，或者是父类返回值的子类。
          --参数列表相同
          --方法名一样
          --重写是父子之间。
         
     **父类当中的静态方法不能被子类覆盖为非静态；父类中非静态不能被覆盖为静态。
       ---实际应用当中：重写就是子类重写父类当中同样的方法。

实例化对象问题！
         --初始源头   
         -实例化一个子类对象时，一定会优先实例化其父类对象。
             并且实例化父类对象的操作是系统自动完成的，不需要我们自己编写代码！
                 --super（）默认存在，不需要显示调用，跟无参构造相同。默认存在，不需要显示定义。
                     如果显示调用，super()必须写在第一行，否则语法报错。       
         -在子类中可以使用super调用方法，也可以访问属性，只能访问父类的公有的信息(包括间接父类)，私有是无法访问的。

        子类的构造函数中可以通过super来访问父类的所有公有信息（属性、方法、构造方法）
         子类的普通方法中通过super可以访问属性和方法，但是不能调用构造方法。

Java中的每一个类，都是一个子类（Object除外），但 不是每一个类都是父类。

super 与 this的区别：
     相同点：super和this都可以访问类中的属性、方法、构造方法
         super、this访问构造方法时，必须写在第一行。
         super、this访问构造方法时，必须写在构造方法中!
     不同点：super时子类访问父类，维护两个类之间的关系。&& this是自己访问自己，维护一个类的关系。
         super 不能访问私有属性和方法，this可以访问私有属性和方法。

通过无参构造创建子类对象时
     -子类无参构造默认调用父类的无参构造。
     -手动调用父类的有参构造，会将默认的无参构造覆盖
通过有参构造创建子类对象时
     -子类有参构造默认调用父类的无参构造 ****
     -手动调用父类的有参构造，会将默认的无参构造覆盖

多态：同一个引用类型，因为实例不同，表现的形式也不同。

向上转型：父类声明指向子类对象。
     1.向上转型：父类声明
        （1）只能调用子类重写的方法，
         （2）或者本身实现，没有被子类覆盖的方法。
         ---子类特有的方法无法被调用，
         ？强转一下，应该可以?
         (3)向上转型，属于自动类型转换。
         **多个子类实现重写的方法，优先调用距离实现类最近的！
     2.向下转型：强制将父类型变为子类型。
         （1）前提：向上转型后，才能向下转型。
         （2）向下转型之前，一定要判断实例的类型。// class cast exception
         （3）向下转型属于强制类型转换！

多态——业务需求，频繁更改代码，可维护性、可扩展性比较差的问题
     ：一个事物，多种表现形式。
     多态在实际使用中，需要建立继承关系，建立接口和实现类的关系。 *****
    
继承和方法重写是实现多态的基础。
     1.定义方法形参（形式参数）的数据类型为父类；实际调用为传入子类的实参
     2.定义方法时，返回值类型为父类，外部调用该方法时使用子类接收

多态衍生：抽象类

抽象类不能在外部实例化！！！
         --但是可以通过实例化继承子类，自动实现实例化抽象类。

没有抽象的构造方法，也没有抽象的静态static 方法。
抽象类中可以包含非抽象的构造方法，    创建子类实例对象时可以调用。

面向对象编程
     开发期间：类是构成Java程序的单位，Java程序通过类来组织其结构
     运行期间：对象是Java程序在运行时的单位，运行期间的Java程序是通过多个对象之间的相互作用关系来完成需求，动态。
    
null:空指针，内存地址的一个值，指空，不存在。
垃圾回收机制GC：是一个独立的巡查线程，GC是一个定时任务，隔一段时间执行一次。

基本数据类型在栈内存中开辟空间，同时直接将具体数值（而不是地址）保存在栈中
     --int numb = null;报错
引用类型在栈中开辟空间，同时在堆中开辟空间，创建对象，将对象地址保存在栈中。

抽象类

在class前加关键字abstract,用于表示当前类为抽象类。

      
     **在抽象类中，可以有普通方法，也可以有抽象方法。
         -抽象方法之只能在抽象类当中声明。
         -在修饰符和返回值之间，添加关键字 abstract,抽象方法没有方法体。
         -不需要立即实现。
        
     ***没有抽象的属性
     抽象类不可被实例化
     抽象方法必须在子类当中被实现，除非子类也是抽象类。
     ——在抽象类的子类当中，只要有一个子类实现了抽象方法，其后代不必一定实现该抽象方法。
    
     抽象类可以有构造?
     -原理：
         抽象类的构造函数用来初始化抽象类的一些字段，
         而这一切都在抽象类的派生类实例化之前发生。
         不仅如此，抽线类的构造函数还有一种巧妙应用：就是在其内部实现子类必须执行的代码。

综合应用——面向接口编程

面向接口编程是常见的一种开发方式。
     -面向接口编程就是将程序的业务逻辑提取出来，以接口的形式去对接不同的业务模块，接口只串联不实现，真正的业务逻辑交给接口
         的实现类来完成，当用户需求发生变更时，只需切换不同的实现类即可。
     （连接松散，低耦合）
    
“低耦合---高内聚”
     低耦合：降低模块之间的链接的紧密程度，模块之间是一种非常松散的状态，利于维护和扩展。
     高内聚：将相关的业务逻辑尽量集中到一个模块中。
    
面向接口编程的优点：
     1.能够最大限度地解耦，降低程序地耦合性
     2.使程序易于扩展
     3.有利于程序的后期维护

如何使用接口:
     默认都是抽象方法，abstract可省略；
     接口中可以定义成员变量，但是有如下要求：
         1.不能定义private、protected的权限修饰符，可以使用public 、默认修饰的成员变量
         2.成员变量必须被初始化（final***)
         3.接口中的成员变量必须是静态static，同时该成员变量还必须是一个常量！
         （static final都可以省略）

成员变量：定义在类中，方法体外的变量，属性。   
局部变量：定义在方法提中的变量
区别：
     1.作用域不同：变量的使用范围
         局部变量仅限于定义它的方法中，方法外无法访问。
         成员变量的作用域在整个类中都是可见的。
    
     2.初始值不同
         属性、成员变量都有一个初始值，初始值根据属性的数据类型来决定。
         基本数据类型：byteintshortlong :0
         char:‘ ‘
         boolean:false
         String引用类型：null

方法重载：（方法允许重名）
     1.同一个类 ***
     2.方法名相同
     3.参数列表不同，个数、数据类型不同
     4.与返回值、访问权限无关。

== 和 equals()的区别？
     ==：栈内存中的值是否相等
         如果数据是基本数据类型，比较的是数据的值是否相等，
         如果是引用类型，比较的是引用地址(数据的内存地址是否相等)
     equals():Object类中定义的一个方法，默认方法体是通过==进行判断的（只能使用引用数据类型进行调用）
         默认是比较数据的内存地址
         重写，按照实际。（equals（）方法经常会被Object的子类进行重写，比较典型，
             String类中的重写--字符串的值是否相等进行判断，改为判断String的数组内容进行比较）

switch(num):num为除long型以外的整数+String（jdk>7）+char
     --switch{}，为独立的作用域
         --无需依次比较，一次找到目标
     --default:当所有条件都不满足的时候，执行default
         可以有，也可以没有；可放置在任意位置；
             -习惯放在首位、末尾，如果不在末尾需要加break;

循环：
     四大要素：
         初始化变量
         判断条件
         循环体
         迭代:无限趋近目标