Java基础之面向对象详解

小鱼儿 2021-09-25 02:16 441阅读 0赞

**目录**

什么是类？

什么是对象？

面向对象的三大特性（封装、继承、多态）

一、封装

访问修饰符

关键字this的含义

二、继承

继承后的特点--成员变量

继承后的特点--成员方法

super和this的含义

父类空间由于子类对象产生

三、多态

多态存在的条件：

创作不易，如果本篇博客对您有一定的帮助，大家记得留言+点赞哦。

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

###        对 [Java][] 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。 ###

# 什么是类？ #

**类**是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称之为属性，成员方法用于描述对象的行为，简称为方法。

public class Student {
        //成员变量
        private String name;//姓名
        private int age;//年龄
    
        //成员方法
        //学习的方法
        public  void study(){
            System.out.println("好好学习，天天向上");
        }
        //吃饭的方法
        public void eat(){
            System.out.println("干饭人干饭时间");
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
        
        //带参构造函数
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        //无参构造函数
        public Student() {
        }

# 什么是对象？ #

**对象** ：是一类事物的具体体现。对象是类的一个 **实例** （对象并不是找个女朋友），必然具备该类事物的属性和行为。

public static void main(String[] args) {
         //创建对象
         Student stu1=new Student("张三",9);
         Student stu2=new Student("李四",9);
         //使用对象访问类中的成员
         stu1.setAge(18);
         stu1.eat();
         stu2.setName("赵四");
         stu2.study();
    
    }

# **面向对象的三大特性（封装、继承、多态）** #

## **一、封装** ##

**封装:**封装是面向对象方法的一个重要原则，它有两个含义：**第一个含义是**，把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位(即对象)；**第二个含义**也称作信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。

**1.使用private关键字来修饰成员变量**

**2.对需要访问的成员变量，提供对应的一对getXxx方法、SetXxx方法。**

public class Student {
        //私有成员变量
        private String name;//姓名
        private int 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;
        }
    }

### 访问修饰符 ###

![20210109101638121.png][]

### **关键字this的含义** ###

*  **this**代表所在类的当前对象的引用（地址值），即对象自己的引用。
 *  方法被哪个对象调用，方法中的this就代表哪个对象。即谁在调用，this就代表谁。

**变量封装了当前值，方法封装了代码和行为，类封装两者以同时提供一堆状态和函数。接口封装了方法。**

## **二、继承** ##

**继承:**继承是一种使用户得以在一个类的基础上建立新的类的技术。**新的类自动继承旧类的属性和行为特征，并可具备某些附加的特征或某些限制。**

**继承**：**就是子类继承父类的属性和行为，使得子类具有与父类相同的属性、相同的行为。子类可以直接访问父类的非私有的属性和行为。**

提高了代码的复用性。类与类之间产生了关系，是**多态的前提**。

class 父类{
        ···
    }
    
    class 子类 extends 父类{
        ···
    }

### **继承后的特点--成员变量** ###

如果子类父类出现不同名的成员变量，代码的访问没有影响。

如果子类父类出现了同名的成员变量，在子类中需要访问父类中非私有成员变量是，需要使用**super关键字**，修饰父类的成员变量。

class Zi extends Fu {
        // Zi中的成员变量
        int num = 6; 
        public void show() { 
            //访问父类中的num 
            System.out.println("Fu num=" + super.num); 
            //访问子类中的num 
            System.out.println("Zi num=" + this.num); 
        } 
    }

### **继承后的特点--成员方法** ###

如果子类父类出现不同名的成员方法，代码的访问没有影响。

如果子类父类出现了同名的成员方法，这时出现了**方法重写**（Override）

方法重写：子类中出现与父类一模一样的方法是（返回值类型、方法名和参数列表都相同），会出现覆盖效果。**声明不变，重新实现。**

//父类
    class Fu { 
        public void show() {
            System.out.println("Fu show"); 
        } 
    }
    //子类
    class Zi extends Fu { 
        //子类重写了父类的show方法 
        public void show() { 
            System.out.println("Zi show"); 
        } 
    }
    //测试类ExtendsDemo
    public class ExtendsDemo{ 
        public static void main(String[] args) { 
            Zi z = new Zi(); 
            // 子类中有show方法，只执行重写后的show方法 
            z.show(); // Zi show 
        } 
    }

### **super和this的含义** ###

*    super：代表父类的存储空间标识，只能出现在方法中（可以理解父类的引用）
 *    this：代表当前对象的引用（谁调用就代表谁）。

### **父类空间由于子类对象产生** ###

在每次创建子类对象时，先初始化父类空间，再创建子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，子类可以随意使用父类成员。**代码体现在子类的构造方法调用时，一定先调用父类的构造方法。**

## 三、多态 ##

**多态:**在收到消息时对象要予以响应，不同的对象收到同一消息可以产生完全不同的结果， 这一现象叫做多态。

### 多态存在的条件： ###

*  1.存在继承关系
 *  2.方法需要重写
 *  3.父类的引用指向子类

//子类的引用  指向——>    子类
    父类类型  变量名 = new 子类对象;
    变量名.方法名();

**父类类型：指子类对象继承父类类型，或者实现的父接口类型。 多态是方法的多态，属性没有多态。**

//抽象的父类
    public abstract class Animal { 
        public abstract void eat();
    }
    //子类Cat
    class Cat extends Animal { 
        public void eat() { 
            System.out.println("吃鱼"); 
        } 
    }
    //子类Dog
    class Dog extends Animal {
        public void eat() {
            System.out.println("吃骨头"); 
        } 
    }
    //测试类Test
    public class Test { 
        public static void main(String[] args) {
            // 多态形式，创建对象 
            Animal a1 = new Cat(); 
            // 调用的是 Cat 的 eat 
            a1.eat(); 
            // 多态形式，创建对象 
            Animal a2 = new Dog(); 
            // 调用的是 Dog 的 eat 
            a2.eat(); 
        }
    }

**在多态的代码中，成员方法的访问规则是：   看new的是谁，就优先用谁，没有则向上找。**

### **创作不易，如果本篇博客对您有一定的帮助，大家记得留言+点赞哦。** ###

[Java]: http://c.biancheng.net/java/
[20210109101638121.png]: /images/20210923/72fff3de6b774af5b810dbe2efb327ac.png