Java面向对象概念全解

╰半橙微兮° 2021-09-21 04:08 374阅读 0赞

> Java四大特性（抽象、封装、继承、多态）

### 一、类 ###

（一）同级类

在一个.java 文件中**可以有多个同级类**（和 public 一样的位置，注意不是内部类），**编译一个 java 文件会生成多个 class 文件**。修饰符只可以 **abstract／final／和无修饰符**，不能是其他的 protected/private/public等修饰符。一个.java文件最多有一个public修饰的类名。

（二）内部类

内部类是一个类当中的一个类，相当于一个类进行了嵌套，就如同循环的嵌套一般。  
内部类有一个特征：**内部类当中可以调用外部类当中的属性和方法，而外部类却不能调用内部类当中的。**

**1.静态内部类**

*  作为类的静态成员，存在于**某个类的内部**。
 *  静态内部类虽然是外部类的成员，但是在**未创建外部类的对象**的情况下，可以**直接创建静态内部类的对象**。静态内部类可以**引用外部类的静态成员变量和静态方法**，但不能引用外部类的普通成员。

**2.成员内部类**

*  作为类的成员，存在于某个类的内部。
 *  **成员内部类可以调用外部类的所有成员**，但只有**在创建了外部类的对象后**，才能调用外部的成员。

**3.局部内部类**

*  存在于某个方法的内部。
 *  局部内部类只能在方法内部中使用，内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁。当外部类的方法结束时，**局部变量**就会被销毁了，**但是内部类对象可能还存在 (只有没有人再引用它时，才会死亡)**。

**4.匿名内部类**

*  匿名内部类之所以匿名是因为匿名内部类的具体名字不会被我们在程序当众编写出来，因为它已经在主方法当中被实例化了。
 *  匿名内部类可以继承两类数据结构：**抽象类或者接口**。
 *  存在于某个类的内部，但是无类名的类。

// 语法
     new 类或者接口的名字 (){ 
      /** *匿名内部类的主体，大括号中是匿名内部类的主体，这个主体就是类或者接口的实现， *如果是类，那么匿名内部类是该类的子类，如果是接口，匿名内部类需要完成接口的实现。 **/
    }

【代码示例】

class people{ 
        public void show(Message message){ 
            message.show();
            System.out.println("people的show打印");
        }
    }
    
    class Message{ 
        public void show(){ 
            System.out.println("这是message的show方法");
        }
    }
    
    public class Demo { 
        public static void main(String args[]){ 
            people p = new people();
            p.show(new Message(){ 
                public void show(){ 
    // super.show();
                    System.out.println("匿名内部类的打印");
                }
            });
        }
    }
    
    // 运行结果
    匿名内部类的打印
    people的show打印

**5.局部内部类和匿名内部类只能访问 final 的局部变量**

当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在。

第一个问题：**内部类对象访问了一个不存在的变量**。为了解决这个问题，**就将局部变量复制了一份作为内部类的成员变量**，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的”copy”。这样就好像延长了局部变量的生命周期。

第二个问题：将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，但是**将局部变量设置为 final**，对它初始化后，就**不让你再去修改这个变量**，就保证了**内部类的成员变量和方法的局部变量的一致性**。这实际上也是一种妥协。

*  final 修饰的成员变量是基本类型，则表示这个**变量的值不能改变**；
 *  final 修饰的变量是引用类型，则**引用的地址**的值不能修改，但是**所指向的对象内容还是可以改变的**

--------------------

### 二、抽象类和接口 ###

**（一）接口**

*  在接口中**只有方法的声明**，没有方法体。
 *  在接口中**只有常量**，因为定义的变量，在编译的时候都会默认加上 **public static final**
 *  在接口中的**方法**，永远都被 public 来修饰，没有修饰的情况下默认是**public abstract**。
 *  接口中**没有构造方法**，也不能实例化接口的对象。（所以接口不能继承类）
 *  接口可以**实现多继承** 也就是 可以**extends interfaceA,interfaceB,**
 *  接口中定义的方法都需要有实现类来实现，如果实现类**不能实现接口中的所有方法则实现类定义为抽象类。**
 *  接口可以**继承接口，用 extends**，但是接口不允许implements

**（二）抽象类**

*  抽象类中**可以有构造方法**
 *  抽象类中可以**存在普通属性，方法，静态属性和方法**。
 *  抽象类中可以**存在抽象方法**，抽象方法不能有方法体。
 *  如果**一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法**。
 *  抽象类中的**抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象**的。
 *  抽象类**不能被实例化**，抽象类和抽象方法必须被 abstract 修饰
 *  关键字使用注意：抽象类中的**抽象方法**（其前有 abstract 修饰）**不能用 private、static、synchronized、native** 访问修饰符修饰，但是可以有 **public、protected 和 default 这些修饰符**。
 *  抽象类可以**实现接口**，但是**抽象类不必实现接口**的方法。但当抽象类不实现接口方法时，继承该抽象类的非抽象类必须实现抽象类的抽象方法和接口方法，但是当抽象类实现接口方法的时候，继承的类就不用在实现该方法了，本质上，接口和抽象类的方法都是abstract 方法，abstract 方法需要实现，沿着继承链一层层找一下，总要有实现该方法的类。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

--------------------

### 三、继承 ###

**（一）重写override**

重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

*  方法名相同，参数类型相同
 *  子类返回类型小于等于父类方法返回类型，
 *  子类抛出异常小于等于父类方法抛出异常，
 *  子类访问权限大于等于父类方法访问权限。

**（二）重载overload**

重载是**在一个类中实现**的，有多个**同名方法，但参数**不一样，包括**参数类型、参数个数**、还可以没有参数，总之每个重载的方法的参数必须不一样。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

**注意：方法名相同，参数相同，只返回值不相同则不算是重载，编译不通过**

**（三）super和this关键字**

**1.this**

this 是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。

this 的用法在 java 中大体可以分为 3 种：

*  普通的直接引用
 *  形参与成员名字重名，用 this 来区分：
 *  引用构造函数

**2.super**

super 可以理解为是指**向自己超（父）类对象的一个指针**，而这个**超类指的是离自己最近的一个父类。**

*  普通的直接引用
 *  子类中的成员变量或方法与父类中的成员变量或方法同名
 *  引用构造函数

**3.注意**

*  super:　它引用当前对象的直接父类中的成员，用来访问直接父类中被隐藏的成员数据或函数（这里指的隐藏的成员变量是指protected修饰的变量），基类与派生类中有相同成员定义时如：super. 变量名， super. 成员函数据名（实参）
 *  this 和 super 不能同时出现在一个构造函数里面
 *  super()函数是在所有子类构造器第一行都存在的（隐式或显示的调用）。这是代表调用基类的无参构造器
 *  当类不存在构造器的时候，java虚拟机是默认给类添加一个无参构造器的，但是当只存在有参构造器，不存在无参构造器的时候，虚拟机不会隐式构造无参构造器，这个时候，子类如果还隐式调用super()，就会编译出错。所以需要显示加上super(形参)；形参内容根据子类决定

class Parent { 
        Parent(String name) { 
            System.out.println("有参构造器+"+name);
        }
    }
    
    public class Child extends Parent { 
        Child() { 
            // super("xsj"); // 没有这个语句，就会报错
            System.out.println("子类无参构造器");
        }
    
        public static void main(String[] args) { 
            Child c = new Child();
        }
    }

（四）Java的单继承

Java是单继承的，一个类最多只能继承一个类，但是接口可以继承多个接口，但这并不违反Java单继承的特性：

*  接口可以继承多个接口是因为接口里面的定义的方法都是未实现的，不会增加复杂性。
 *  接口不是类，而是对类的一组需求的描述。接口绝不能含有实例域，也不能在接口中实现方法。接口可以实现多继承**不会增加代码的复杂性**。
 *  **多继承是发生在执行期间的**，而不是在编译期间，所以可以编译通过，并且不违背 Java 是单继承的。
 *  接口定义的都是抽象的方法，而且不能在接口中实现方法。所以，**接口继承多个接口，并不会使接口的结构变得很复杂。相反，这样做，还能给一个团队在开发的过程中，提供很多便利**。

--------------------

### 四、多态 ###

（一）定义

多态就是指程序中定义的**引用变量所指向的具体类型**和通过该引用变量**发出的方法调用**在编程时并不确定，而是**在程序运行期间才确定**，即一个**引用变量倒底会指向哪个类的实例对象**，该引用变量**发出的方法调用**到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序**运行时才确定具体**的类，这样，不用修改源程序代码，就可以**让引用变量绑定到各种不同的类实现上**，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让**程序可以选择多个运行状态，这就是多态性**。

关于多态的问题，可以大体概括为：\*\*编译看左边，运行看右边。\*\*意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。

class Base
    { 
        public void method()
        { 
            System.out.println("Base");
        } 
    }
    class Son extends Base
    { 
        public void method()
        { 
            System.out.println("Son");
        }
         
        public void methodB()
        { 
            System.out.println("SonB");
        }
    }
    public class Test01
    { 
        public static void main(String[] args)
        { 
            Base base = new Son();
            base.method();
            base.methodB();
        }
    }

上述代码编译不通过，因为base是没有methodB方法的。**编译看左边，运行看右边**。要先编译通过，才能运行。但是这个也存在特殊情况：

public class Father {  
        public void say(){  
            System.out.println("father"); 
        } 
        public static void action(){  
            System.out.println ("爸爸打儿子！"); 
        } 
    } 
    public class Son extends Father{  
        public void say() {  
            System.out.println("son"); 
        }
       public static void action(){  
            System.out.println ("打打！"); 
        }
        public static void main(String[] args) {  
            Father f=new Son(); 
            f.say(); 
            f.action(); 
        } 
    }

当调用 say 方法执行的是 Son 的方法，也就是重写的 say 方法  
而当调用 action 方法时，执行的是 father 的方法。

*  普通方法，运用的是动态单分配，是根据 new 的类型确定对象，从而确定调用的方法；
 *  静态方法，运用的是静态多分派，即**根据静态类型确定对象**，因此不是根据 new 的类型确定调用的方法

（二）代码初始化顺序

在继承中代码的执行顺序为：

*  父类静态属性，父类静态代码块
 *  子类静态属性，子类静态代码块
 *  父类非静态对象，父类非静态代码块
 *  父类构造函数
 *  子类非静态对象，子类非静态代码块
 *  子类构造函数

注意：

static{ }//静态块
    { }//构造块

**静态块在一个程序里面只执行一次；**  
而构造块是，只要建立一个对象，构造代码块都会执行一次。  
静态块优先于主方法的执行，静态块优先于构造快，然后是构造方法的执行，而且静态块只执行一次！

public class Demo { 
        class Super { 
            int flag = 1;
    
            Super() { 
                test();
            }
    
            void test() { 
                System.out.println("Super.test() flag=" + flag);
            }
        }
    
        class Sub extends Super { 
            Sub(int i) { 
                flag = i;
                System.out.println("Sub.Sub()flag=" + flag);
            }
    
            void test() { 
                System.out.println("Sub.test()flag=" + flag);
            }
        }
    
        public static void main(String[] args) { 
            new Demo().new Sub(5);
        }
    }
    
    //执行结果
    Sub.test()flag=1
    Sub.Sub()flag=5

public class Base
    { 
        private String baseName = "base";
        public Base()
        { 
            callName();
        }
     
        public void callName()
        { 
            System. out. println(baseName);
        }
     
        static class Sub extends Base
        { 
            private String baseName = "sub";
            public void callName()
            { 
                System. out. println (baseName) ;
            }
        }
        public static void main(String[] args)
        { 
            Base b = new Sub();
        }
    }
    //输出为null

这里的区别就在于属性的修饰符，第一个修饰的默认，所以在同一类下，子类可以继承父类的属性。

子类不继承父类的属性的情况：

*  父类的属性修饰不允许，比如private，跨包情况下的默认修饰符，此时是直接编译不通过
 *  父类和子类有相同的属性，此时子类是不继承父类的属性的，是使用自己的属性，即使该属性可能还未初始化。

在第二个例子，子类也存在baseNames属性，子类无法继承，当调用方法的时候，子类的属性还没有初始化，父类又不能调用，所以只能是默认值null。如果去掉baseName这个属性，结果就是base。

还有一个需要注意的地方：子类的类修饰符是static，因为子类是父类的成员内部类，如果未加static，在成员内部类没有生成对象的时候不能调用。

**不加static的调用方式：new base().new sub();**

--------------------

**【Java 面试那点事】**

**这里致力于分享 Java 面试路上的各种知识，无论是技术还是经验，你需要的这里都有！**

**这里可以让你【快速了解 Java 相关知识】，并且【短时间在面试方面有跨越式提升】**

**面试路上，你不孤单！**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/d09db1316675417daae9d8f8e05ed1ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 1]: /images/20210920/72d59960fae0427a8f9ebfb270afa637.png