目录

1.类和对象

1.1 概念

1.2 类的定义

1.3 对象的使用

2. 封装

2.1 封装思想

2.2 PRivate 和 this

3. 继承

3.1 继承思想

3.2 方法重写

3.3 Java继承的注意事项：

4. 多态

4.1 多态思想

4.2 多态中的转型

---

如何理解面向对象？

简单的说就是把事物和操作事物的方法汇集到一起，形成一个相互依赖的整体。

下面我们来了解面向对象的基础知识

1.类和对象

1.1 概念

对象：客观存在的事物都是对象，比如一只猫，一只狗

类：对事物的一种描述，比如猫睡觉，猫抓老鼠

类的组成：

属性：指事物的特征，例如：电脑（品牌、价格）

行为：指事物能执行的操作，例如，电脑使用（看电影、打游戏）

1.2 类的定义

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

示例代码：

public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

1.3 对象的使用

创建对象的格式：

        类名 对象名 = new 类名(); 调用成员的格式：

        对象名.成员变量

        对象名.成员方法();

示例代码：

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

2. 封装

2.1 封装思想

概述：封装是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法

好处：通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

使用封装前，需要先了解一些修饰符

2.2 private 和 this

private，意思为私有的，它是用来修饰成员变量和成员方法的

this，修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

从单词意思上就知道被private修饰的成员，只能在本类进行访问

那么针对private修饰的成员变量，如果需要被其他类使用，则提供相应的操作：

1）提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

2）提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

示例代码：

public class Animal {
    private String name;
    private int age;

    提供get/set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    //成员方法
    public void show() {
        System.out.println(name+","+age);
    }

public class test {
    public static void main(String[] args) {
        //创建对象
        Animal a = new Animal();
        //给成员变量赋值
        a.setName("喵喵");
        a.setAge(20);
        //调用show方法
        a.show();
    }
}

运行结果：

3. 继承

3.1 继承思想

继承是什么？

一个类（子类）拥有另一个类（父类）的所有功能，不需要编写原来的类，还可以对功能拓展

继承的利与弊：

好处：提高了代码的复用性，提高了代码的维护性

弊端：削弱了子类的独立性，父类变化子类也跟着变化

子类默认访问父类的无参构造方法，但也可以通过suPEr关键字调用有参的构造方法

下面我们通过代码了解子类继承的构造方法：

1.创建一个Animal类，有属性name和age，提供有参和无参的构造方法

public class Animal {
    String name;
    int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2.创建一个Cat类，并继承Animal类，声明方法catMouse

public class Cat extends Animal{
    public Cat(){
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    public void catMouse(){
        System.out.println("猫抓老鼠");
    }
}

3.创建一个测试类Test

public class Test {
    public static void main(String[] args) {
        Cat c1 = new Cat();  //创建对象c1，使用无参构造方法
        c1.setName("喵喵");
        c1.setAge(20);
        System.out.println(c1.getName()+" "+c1.getAge());

        Cat c2 = new Cat("咪咪",15);   //创建新的对象c2,使用有参构造方法
        System.out.println(c2.getName()+" "+c2.getAge());

        c1.catMouse();  //调用方法
    }
}

4.运行结果

3.2 方法重写

继承还有一个重要内容，就是方法重写

方法重写就是子类和父类的方法名一样，参数列表也一样

为什么要进行方法重写：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

override注解：

用来检测当前的方法，是否是重写的方法，起到【校验】的作用

方法重写注意事项

1. 私有方法不能被重写(父类私有成员子类是不能继承的) 2. 子类方法访问权限不能更低(public > 默认 > 私有)

代码举例：

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {
    /* 编译【出错】，子类不能重写父类私有的方法*/
//    @Override
//    private void show() {
//        System.out.println("Zi中show()方法被调用");
//    }

    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
//    @Override
//    private void method() {
//        System.out.println("Zi中method()方法被调用");
//    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

运行结果：

3.3 Java继承的注意事项：

1） Java中类只支持单继承，不支持多继承             错误范例：class A extends B, C { } 2）Java中类支持多层继承

4. 多态

4.1 多态思想

多态就是同一个对象，在不同时刻表现出来的不同形态

多态的前提：

1.要有继承或实现关系

2.要有方法的重写

3.要有父类引用指向子类对象

多态的利弊：

好处：提高了程序的扩展性

弊端：不能使用子类的特有成员

4.2 多态中的转型

向上转型：父类 对象名 = new 子类

向下转型：子类型 对象名 = (子类型)父类引用

举例说明：

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

public class Test {
    public static void main(String[] args) {
        //多态
        //向上转型
        Animal a = new Cat();
        a.eat();
        
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

运行结果：

 总结：面向对象的三大基本特征介绍就完毕了，但面向对象不止这些特征。后续我会发布新的内容，请持续关注！！！