Java面向对象知识总结+思维导图

🔖面向对象

📖 Java作为面向对象的编程语言，我们首先必须要了解类和对象的概念，本章的所有内容和知识都是围绕类和对象展开的！

▐ 思维导图1

▐ 类和对象的概念

• 简单来说，类就是对具有相同特征的一类事物的描述，而对象是类的具体实例.

• 比如说 '车' 就是一个大的概念，它可以具体化为奔驰、宝马、帕拉梅拉。那么车就是一个类，奔驰车就是以车类为模版的一个实例化对象。

• 一个类中包含成员变量和成员方法

上图程序最终输出：50W帕拉梅拉 is running

▐ 构造方法

• 构造方法的作用是初始化对象，并且分为无参构造方法和有参构造方法

• 构造方法的方法名与类名相同，没有返回值，且不需要void修饰。

• 如果一个类没有定义构造方法，Java会提供一个默认的无参构造方法

• 在一个类中可以有多个构造方法 ( 构造方法可以重载 ).

public class Car {
    String name;
    String price;
    //无参构造方法
    public Car(){
        name="帕拉梅拉";
        price="50W";
        System.out.println(name+price);
    }
    //有参构造方法
    public Car(String name,String price){
        this.name=name;
        this.price=price;
        System.out.println(name+price);
    }

    public static void main(String[] args) {
        new Car();//输出: 帕拉梅拉50W
        new Car("奔驰","40W");//输出: 奔驰40W
    }
}

▐ 方法的重载

• 当一个类中有多个名字相同的方法时，可以通过参数的个数、类型、顺序，在调用时进行区分

• 方法的重载与返回值类型无关

public class Car {
    String name;
    String price;
    int count;
    //有参构造方法
    public Car(String name,String price){
        this.name=name;
        this.price=price;
        System.out.println(name+price);
    }
    //参数的类型不同
    public Car(String name,int count){
        this.name=name;
        this.count=count;
        System.out.println(name+count);
    }
    //参数顺序不同
    public Car(int count,String name){
        this.name=name;
        this.count=count;
        System.out.println(name+count);
    }
    public static void main(String[] args) {
        new Car("奔驰","40W");//输出:  奔驰40W
        new Car("帕拉梅拉",6);//输出:  帕拉梅拉6
        new Car(6, "帕拉梅拉");//输出: 帕拉梅拉6
    }
}

▐ this与super关键字

• this在类中表示当前正在访问的对象，主要是为了区分成员变量和局部变量

▐ 封装

• 即为成员变量或成员方法添加一个访问权限修饰符，使外界不得随意操作，主动权在类的手中 .

📖访问权限修饰符

• public 公共权限 ------- 修饰的成员在任何地方都可以访问到.

• protected 受保护权限 ---- 在本类 / 同包的其他类中可以访问到，及不同包的子类.

• default 默认权限 ------- 在本类 / 同包的其他类中可以访问到.

• private 私有权限 ------ 只能在本类访问到. (常用)

protected和默认(default)的区别就是,protected可以在不同包的子类中访问

• 封装起来之后，通常是通过类中向外提供的特殊方法进行访问，这样就可以加入控制语句

public class Car {
    private String name;
    //向外提供set和get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        //加入控制语句
        if(name.length()<5){
            this.name = name;
        }
    }
}

▐ 代码块

• 代码块就是在类中声明的一个没有名字的代码块，分为实例代码块和静态代码块

• 实例代码块: 在每次创建对象时执行，静态代码块: 在类被加载时自动执行

格式： { 实例代码块内容 } static { 静态代码块内容 }

📖类什么时候会被加载？

• 运行类中的main方法时.

• 访问类中的静态成员变量或静态成员方法时.

• 创建类的对象时.

public class Car {
    {
        System.out.println("实例代码块");
    }
    static {
        System.out.println("静态代码块");
    }

    public static void main(String[] args) {
        new Car();
        new Car();
        new Car();
        /*
     依次输出:
        静态代码块
        实例代码块
        实例代码块
        实例代码块
         */
    }
}

▐ static关键字

• static静态的意思，static关键字可以修饰类中的成员变量，成员方法，代码块，内部类.

（不能修饰构造方法）

• static修饰成员变量：

静态成员变量也称类变量，在内存中只有一份，所有对象可以共享，一般情况下，将类中所有对象都相同的属性设置为静态的。

• static修饰成员方法：

修饰的成员方法也称为类方法，可以直接使用类名访问，在静态的方法中只能访问静态的成员变量，非静态的方法中可以使用静态的成员变量。

• static关键字修饰的属性特点：

• 随着类的加载而加载

• 优先于对象存在

• 静态成员被所有对象共享

• 可以直接使用类名访问

注意：

• 静态的方法中，只能使用静态的成员变量，因为他们都是随着类的加载而加载的；

• 一旦方法中使用了非静态的成员变量，那么此方法就不能定义为静态的；但非静态的方法中可以使用静态的成员变量

▐ 思维导图2

📖面向对象的三大特征：封装，继承，多态是本章的重点，第二部分将围绕继承和多态展开

▐ 继承

• 简单来说，继承就是将某一事物的共同属性抽取出来单独定义一个类 (父类)，其它子类可以继承父类，这样不仅实现了代码的复用，子类也可以扩展自己特有的功能。

• 举个简单的例子，现在有三个动物：猫，狗，鸟，它们都有一个共同属性：名字name，那么就可以将name属性定义在一个Animal动物类中，也就是父类，这样就不需要在猫，狗，鸟类中分别定义name属性了，它们只需继承Animal父类即可。

• 继承具有传递性，即一个类只能直接继承一个类；但可以间接继承多个类。

• 继承使用的是extends关键字，子类继承父类后，拥有了父类的成员变量和成员方法

• 子类不能继承父类中的私有属性

public class Cat extends Animal{
   //Cat继承Animal的成员变量和成员方法，但不能访问私有成员
}

📖当一个类没有显示继承其他类的时候默认继承object类，Object类是java类体系中最大的类，Object类之上再也没有别的类。

▐ 多态

• 多态的使用前提是两个类存在继承关系

• 多态也称向上转型，也就是将子类类型向上转为父类类型

Animal dog = new Dog();

• 多态实现了用父类类型表示任意子类类型的对象，利于程序扩展

📖通过一个案例给大家解释下吧！

public class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

public class Dog extends Animal{
    @Override//方法的重写
    public void makeSound() {
        System.out.println("Dog is barking");
    }
 
    public static void main(String[] args) {
        Animal dog = new Dog();//现在我们可以使用Animal类的引用来引用Dog对象
 
        dog.makeSound();  //输出Dog is barking
    }
}

在上述案例中，Animal引用的是一个Dog对象，但是调用的是Dog类中重写的makeSound()方法，这就是多态的效果！