4、java面向对象

柔情只为你懂 2022-01-21 23:19 166阅读 0赞

java面向对象

1、面向对象概念：
        举例：大象装进冰箱。
            面向过程：强调的是过程（动作）。
                打开冰箱
                存储大象
                关上冰箱
                
            面向对象：强调的是对象（实体）。冰箱自带打开、存储、关闭等功能。
                冰箱打开
                冰箱存储
                冰箱关闭
    
        特点：
            面向对象就是一种常见的思想，符合人们的思考习惯。
            面向对象的出现，将复杂的问题简单化。
            面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。
        
    
    
    2、类与对象的关系：
        类是拥有相同行为特征对象的一个抽象概念。事物的描述。
        对象是类这个抽象概念中事实存在的个体。该类事物的描述。
        在java中对象通过new来创建的。
        
        范例：
            public class Car {
                private int num;//汽车轮子数量
                private String color;//汽车车身颜色
    
                public int getNum() {
                    return num;
                }
    
                public String getColor() {
                    return color;
                }
    
                public void setNum(int num) {
                    this.num = num;
                }
    
                public void setColor(String color) {
                    this.color = color;
                }
    
                @Override
                public String toString() {
                    return "Car{" +
                            "num=" + num +
                            ", color='" + color + '\'' +
                            '}';
                }
            }
    
            主函数{
                Car car = new Car();//car就是一个类类型的引用变量，指向了该类的对象
            }
            
            匿名对象：当对象方法仅进行一次调用时，就可以简化成匿名对象。
                范例：
                    new Car().getColor();
    
    
    3、封装（三大特性之一）：
        是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
    
        好处：
            将变化隔离。
            便于使用。
            提高重用性。
            提高安全性。
        封装原则：
            将不需要对外提供的内容都隐藏起。
            把属性都隐藏，提供公共方法对其访问。
        
        private:
            私有，是一个权限修饰符，用于修饰成员。
            私有的内容只在本类中有效。
        
    
    4、构造函数：
        特点：
            1）函数名与类名相同。
            2）不用定义返回值类型。
            3）没有具体的返回值。
        
        作用：
            给对象进行初始化。————构建创造对象时调用的函数。
    
        注意：
            1）默认构造函数的特点。
                创建对象都必须要通过构造函数初始化。
                一个类中如果没有定义过构造函数，那么类中会有一个默认的空构造函数。如果定义了制定的构造函数，那么类中的默认构造函数就没有了。
    
            2）多个构造函数是以重载的形式存在的。
        
        和一般函数区别：
            构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
            一般函数：对象创建后，需要函数功能时才调用。
        
            构造函数：对象创建时，会调用只调用一次。
            一般函数：对象创建后，可调用多次。
    
        什么时候定义构造函数呢？
            在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。
        
      
    5、this关键字：
        特点：
            this关键字代表其所在函数所属对象的引用。即：本类对象的引用。
            也就是，哪个对象调用了this所在的函数，this就代表哪个对象。
        
        什么时候使用this关键字呢？
            当在函数类需要调用该函数的对象时。
            当局部变量和成员变量重名，可以用关键字this来区分。
        
        this调用构造函数时注意：
            只能定义在构造函数的第一行，因为初始化动作要先执行。
    
        基本应用：
            判断是否为同龄人：
                public boolean compare(Person p){
                    return this.age == p.age;
                }
    
    
    6、static关键字：
        主要用于修饰成员（成员变量和成员函数）。
    
        被修饰后的成员具有以下特点：
            1）随着类的加载而加载。
            2）优先于对象存在。
            3）被所有对象共享。
            4）可以直接被类名调用。
        
        使用注意：
            1）静态方法只能访问静态成员。
            2）静态方法中不可以写this、super关键字。
            3）主函数是静态的。
    
        成员变量和静态变量的区别？
            1） 两个变量的生命周期不一样：
                成员变量随着对象的创建而存在，随着对象的被回收而释放。
                静态变量随着类的加载而存在，随着类的消失而消失。
            2） 调用方式不同：
                成员变量只能被对象调用。
                静态变量可以被对象调用，还可以被类名调用。
            3）  别名不同：
                成员变量也被成为实例变量。
                静态变量被成为类变量。
            4） 数据存储位置不同：
                成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
                静态变量数据存储在方法区中。（方法区中的静态区）
    
        静态代码块：
            随着类的加载而加载，而且只执行一次。
    
            作用：
                用于给类进行初始化。因为有的类不需要对象，可直接调用静态代码块。
    
    
        静态方法和构造方法的区别？
            静态方法：随着类的加载而加载，而且只执行一次。
            构造方法：是给对应的对象进行针对性的初始化。
            构造代码块：可以给所有对象进行初始化。
    
    
    
    7、继承（三大特性之二）：
        java中支持单继承，不直接支持多集成，但对c++中的多继承机制进行改良。
            单继承：一个子类只能有一个直接父类。
            多继承：一个子类可以有多个直接父类。————不直接支持，是因为当两个父类中有同名的方法时，就会有调用不确定性。
                在java中通过多实现的方式来体现它！
    
        java支持多层（多重继承）。
            c继承b，b继承a。就会出现继承体系，当要使用一个继承体系时：
                查看该体系中的顶层类，了解该体系的基本功能。
                创建体系中的最子类对象，完成功能的使用。
    
    
        好处：
            提高了代码的复用性。
            让类与类之间产生了关系，给第三个特征多态提供了前提。
    
        什么时候定义继承呢？
            当类与类之间存在所属关系的时候，就定义继承。xxx是yyy中的一种，xxx就可以继承yyy的一种。
            所属关系： is a 关系。
    
        具体的体现：
            在子父类之中：
                1）成员变量。
                    当本类中的成员和局部变量同名重名用this区分。
                    当子父类中的成员变量同名用super区分为父类。
    
                    this和super的区别：
                        this代表本类对象的引用。
                        super代表父类的空间。
                    范例：
                    calss fu{
                        int num = 4;
                    }
    
                    class zi extends fu{
                        int num = 5;
                        void show(){
                            sout(this.num + "加" + super.num);
                        }
                    }
                    主函数：{
                        zi z = new zi();
                        z.show();
                    }
                    打印：4加5
    
                2）成员函数。
                    当子父类中出现成员函数一模一样的情况下：
                        会运行子类的函数。这种现象被称为覆盖操作。
                    函数的两个特性：
                        1）重载：同一个类中。overload。
                        2）覆盖（重写）：子类中，覆盖也成为重写（复写）。override。
    
                            重写注意事项：
                                1）子类方法重写父类方法时，子类权限必须要大于等于父类的权限。
                                2）静态只能重写静态，或被静态重写。
                            
                            什么时候使用重写操作？
                                当对一个类进行子类的扩展时，子类需要保留的功能声明，但需要定义子类中该功能的特有内容时，就使用重写操作完成。
                                
                    范例：
                    calss fu{
                        void show(){
                            sout("old num");
                        }
                    }
    
                    class zi extends fu{
                        void show(){
                            sout("new pic");
                            sout("new img");
                            this.show();
                        }
                    }
                    主函数：{
                        zi z = new zi();
                        z.show();
                    }
    
                3）构造函数。
                    在子类构造对象时，发现访问子类构造函数时，父类也运行了，原因是：在子类的构造函数中，第一行有一个隐式语句。super();————调用父类的构造函数。
    
                    子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
                
    8、final关键字
        继承弊端：打破了封装性。用final禁止继承。
        1）可以修饰类。方法、变量。
        2）修饰的类不可以被继承。
        3）修饰的方法不可以被重写。
        4）修饰的变量是一个常量。只能在初始化时被赋值一次。
            为什么要使用final修饰变量？
                如果在程序中有一个数据是固定的，那么直接1使用这个数据就可以了，并且这个变量名称和值不能变化，加上final固定。
                写法规范： 常量所有字母都大写，多个单词，中间用 _ 连接。
        5）内部类只能访问被修饰的局部变量。
    
    
    9、抽象类（基于继承）————abstract
        抽象：笼统，模糊，不具体。
    
        特点：
            1）方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
            2）抽象类不可以被实例化。为什么？因为调用抽象方法没有意义。
            3）抽象类必须由其子类重写了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。
    
        范例：
         abstract calss 犬科{
             abstract void 吼叫();
         }
    
         class 狗 extends 犬科{
             sout("汪汪");
         }
    
         class 狼 extends 犬科{
             sout("嗷~~嗷~~");
         }
    
        提出抽象类的五个问题：
            1）抽象类中有构造函数吗？
                有，用于给其子类进行初始化。
    
            2）抽象类可以不定义抽象方法吗？
                可以，但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。通常这个类中有方法体，但是没有内容。
            
            3）抽象关键字不可以和哪些关键字共存？
                private 不行 ———— 因为抽象方法必须被重写。非法修饰符组合。
                static  不行 ———— 如果成员变静态，则不需要对象，抽象方法即无意义。
                final   不行 ———— 因为无法被重写。
            
            4）抽象类和一般类的异同点？
                异： 一般类有足够的信息描述事物。抽象类描述事物的信息可能不足。
                    一般类中不能第一抽象方法，只能定义非抽象方法。抽象类中可以定义抽象方法，同时可以定义非抽象方法。
                    一般类可以被实例化。抽象类不可以被实例化。
                同：都是用来描述事物的，都在内部定义了成员。
            
            5）抽象类一定是一个父类吗？
                一定是父类。
                因为某个类继承了抽象类，一定要重写其所有抽象方法才可以对其实例化，否则该类还是抽象类！
        
    
    10、接口 interface
        当一个抽象类中的方法都是抽象方法时，这时候可以将抽象类定义成接口。
    
        格式：
            interface {}
    
        接口中的成员修饰符都是固定的：
            1）成员常量（全局变量）：public static final
            2）成员函数（抽象方法）：public abstract
            3）发现接口中的成员都是public的
        由此得出结论：接口中的成员都是公共的权限。
    
        接口不再使用继承，使用 implements 来实现接口。
    
        范例：
            interface demo{
                public static final int num = 4;
                void show();
            }
    
            calss demoImpl implements demo{
                @Override
                public void show(){
                    sout("我是一个接口中抽象方法的实现方法"); 
                }
            }
        
        在java中不支持多继承，因为会出现调用的不确定性。
        所以java将多继承机制进行了改良，在java中变成了多实现。
        一个类可以实现多个接口。
    
        范例：
            class Test implements 接口一,接口二{
                方法体;
            }
    
        一个类在继承另一个类的同时，还可以实现多个接口。接口的出现避免了单继承的局限性。
    
        细节：
            类与类之间是继承关系。
            类与接口之间是实现关系。
            接口与接口之间是继承关系。而且接口可以多继承。实现子接口时需重写子接口及所有父接口的所有抽象方法。
        
        特点：
            1）接口是对外暴露的规则。
            2）接口是程序的功能拓展。
            3）接口的出现降低了耦合性。
            4）接口可以用来多实现。
            5）类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
            6）接口和接口之间可以有继承关系。
        
        凡是对外暴露的东西都可以被称之为接口。
    
    
        接口类与抽象类的异同点？
            
            同：都是不断向上抽取而来的。
    
            异： 1）抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。
                2） 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
                    接口中只能定义抽象方法，必须由子类区实现。
                3） 抽象类的继承是 is a 关系。在定义该体系基本共性内容。
                    接口的实现是 like a 关系。在定义该体系额外功能。
    
    
    
    11、多态
        定义：某一种事物的多种存在形态。
    
        例子：父类 名 = new 子类();
            动物中猫。狗。
            猫这个对象对应的类型就是猫类型。猫 x = new 猫();
            同时猫也是动物中的一种们也可以把猫称为动物。动物 y = new 猫();
            动物是猫和狗等具体事物中抽取出来的父类型，父类型引用指向了子类对象。
        
        对象的多态性。
            猫这类事物即具有猫的形态，又具备着动物的形态。这就是对象的多态性。
            简单说就是一个对象对应着不同类型。
    
        多态在代码中的体现：
            父类或者接口的引用指向其子类的对象。