1-8 面向对象 & final & static

WayserKON

已于 2022-09-06 11:14:02 修改

阅读量61

点赞数

文章标签： java 开发语言后端

于 2022-01-06 20:13:25 首次发布

本文链接：https://blog.csdn.net/langkeyring/article/details/122351378

版权

本文深入解析了面向对象编程的核心概念，包括封装的私有变量与getter/setter、this关键字的应用、访问控制修饰符、单继承与多态示例，以及继承中的构造方法调用规则。理解这些有助于提升程序设计的灵活性和模块化.

摘要由CSDN通过智能技术生成

面向对象简介

面向对象程序设计（object oriented programming 简称OOP）
对象是一个由信息（变量）及对信息进行处理（方法）的描述，其本质是对现实事物的特征和变化规律建立的模型。

面向对象三要素

封装

将成员变量设置为私有，然后提供get和set方法给外界访问。
优点：

能够减少耦合
隐藏实现细节等信息
安全

this关键字

this关键字，表示当前类的对象
this关键字在程序中三种常见的用法：

通过 this 关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突的问题；
通过 this 关键字调用成员方法；
构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但是可以在一个构造方法中去使用 "this([参数1，参数2…])"的形式去调用其他构造方法。

使用 this 调用类的构造方法时需要注意以下几点：

只能在构造方法中使用 this 关键字去调用其他的构造方法，不能在成员方法中使用this关键字调用构造方法；
在构造方法中，使用 this 关键字调用构造方法的语句必须放在第一行，且只能出现一次；
不能在一个类的两个构造方法中使用 this 互调，这种写法会编译报错。

访问控制修饰符

在这里插入图片描述

继承

所有类都有父类，即所有类都派生于Object类
只能单亲继承，即每一个子类只能有一个父类
子类只能继承父类的非private修饰的变量和方法

super关键字

表示当前类的父类对象
可以使用super关键字实现对父类变量和方法的访问
super()和this()不能同时用

重写

重写发生在子父类当中
方法名、参数列表均相同
返回值类型必须相同或相容。（或是其父类返回值类型的子类）
子类方法的访问权限不能缩小
静态方法（static）不能进行重写（因为静态资源只加载一次）

重载

判断重载的依据：重载的是方法的参数列表

发生在同一个类中
方法名相同
参数列表不同（个数，数据类型，顺序），注意：参数列表不同跟变量名称没关系
返回值的类型是否改变，跟方法是否重载没关系，不能作为重载的依据

实例

通过C实例的父类方法调用重写方法，还是用C实例确认范围。

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.fun();
        
        C c = new C();
        // c调用了A的fun()，其中A.fun()中的pick()会先往上确认父类AA.pick()存在，然后一直向下找，直到 C，得到最底层的重写方法（即B的重写）并执行。
        c.fun();

        A cc = new C();
        // 同上
        cc.fun();
    }

}

class AA{
    public void pick(){
        System.out.println("AA pick");
    }
}

class A extends AA{
    public void fun(){
        System.out.println("A");
        pick();
    }
}

class B extends A{
    @Override
    public void pick(){
        System.out.println("B pick");
    }
}

class C extends B{

}

多态

代码当中体现多态性，其实就是一句话： 父类引用指向子类对象

抽象类

抽象类不能被实例化。
抽象类不一定有抽象方法，有抽象方法一定是抽象类。
非抽象类继承抽象类，需要实现父类所有抽象方法。
抽象类可包含抽象方法、非抽象方法（包括构造方法）以及变量。
抽象方法不能有方法体。

public abstract class Main(){
	public int x;
	//抽象方法
	public abstract void fun();
	//非抽象方法
	public void fun2(){
        
    }
}

接口

一个接口可以extends多个接口
一个类只能extends一个类，但是可以implements多个接口
一个类同时声明继承父类和继承接口时，先extends再implements
接口内只能存在final常量和抽象方法
接口内的方法一定默认用public abstract修饰，且public abstract可省略不写。
接口内的变量一定默认用public final static修饰，且public final static可省略不写。

public interface Interf1 {
    int x = 1;	//public final static修饰的变量
    void fun();	//public abstract修饰的方法
}

public class Main extends Fu implements Interf1, Interf2{
	@Override
    public void fun() {
        //----
    }
}

接口多继承实例

public class Test {
    public static void main(String[] args) {
        AB ab = new D();
        A a = new C();
        A aa = ab;
//        AB abab = a;  // 报错

        // 有AB构造，走AB构造
        // 没有AB构造，A构造和B构造同时存在时报错，A和B只存在一个，则走存在的那个
        E e = new E(ab);
    }

}

interface A{

}
interface B{

}

interface AB extends A, B{

}

class C implements A{

}
class D implements AB{

}

class E{
    E(){

    }
    E(A a){
        System.out.println("a");
    }
//    E(B b){
//        System.out.println("b");
//    }
//    E(AB ab){
//        System.out.println("ab");
//    }
}

内部类

public class Main {
    class In1{
        //普通内部类
    }

    static class In2{
        //静态内部类
    }
    public static void main(String[] args) {
        ArrayList list = new ArrayList<String>(){   
            //匿名内部类
            @Override
            public String toString() {
                String str = "";
                for (String s: this){
                    str += s;
                }
                return str;
            }
        };
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);
    }
}