面向对象三大特征

心已赠人 2023-10-13 20:47 16阅读 0赞

#### java面向对象三大特征 ####

*   *  1 封装
     *   *  private关键字
         *  this关键字
         *  封装思想
         *  构造方法
     *  2.继承
     *   *  继承的实现
         *  继承的好处和弊端
         *  Java中继承的特点
         *  this&super关键字
         *  继承中构造方法的访问特点
         *  方法重写
         *  方法重写的注意事项
         *  权限修饰符
         *  抽象类
         *   *  抽象类的概述
             *  抽象类的特点
             *  抽象类的案例
         *  final
     *  3.多态
     *   *  多态的概述
         *  多态中的成员访问特点
         *  多态的好处和弊端
         *  多态中的转型
         *  多态中转型存在的风险和解决方案

### 1 封装 ###

#### private关键字 ####

**概述 :** private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

**特点 :** 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用， 提供相应的操作

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

提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰  
示例代码：

/*
        学生类
     */
    class Student {
        
        //成员变量
        String name;
        private int age;
    
        //提供get/set方法
        public void setAge(int a) {
        
            if(a<0 || a>120) {
        
                System.out.println("你给的年龄有误");
            } else {
        
                age = a;
            }
        }
    
        public int getAge() {
        
            return age;
        }
    
        //成员方法
        public void show() {
        
            System.out.println(name + "," + age);
        }
    }
    /*
        学生测试类
     */
    public class StudentDemo {
        
        public static void main(String[] args) {
        
            //创建对象
            Student s = new Student();
            //给成员变量赋值
            s.name = "林青霞";
            s.setAge(30);
            //调用show方法
            s.show();
        }
    }

#### this关键字 ####

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

*  方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
 *  方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量  
    **代码实现 :**

public class Student {
        
        private String name;
        private int age;
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void show() {
        
            System.out.println(name + "," + age);
        }
    }

#### 封装思想 ####

1.  **封装概述**  
    是面向对象三大特征之一（封装，继承，多态）  
    是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
2.  **封装原则**  
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问  
    成员变量private，提供对应的getXxx()/setXxx()方法
3.  **封装好处**  
    通过方法来控制成员变量的操作，提高了代码的安全性  
    把代码用方法进行封装，提高了代码的复用性

#### 构造方法 ####

**格式注意 :**

*  方法名与类名相同，大小写也要一致
 *  没有返回值类型，连void都没有
 *  没有具体的返回值（不能由retrun带回结果数据）

**执行时机 ：**

*  创建对象的时候调用，每创建一次对象，就会执行一次构造方法
 *  不能手动调用构造方法

\*\*示例代码：

class Student {
        
        private String name;
        private int age;
    
        //构造方法
        public Student() {
        
            System.out.println("无参构造方法");
        }
    
        public void show() {
        
            System.out.println(name + "," + age);
        }
    }
    /*
        测试类
     */
    public class StudentDemo {
        
        public static void main(String[] args) {
        
            //创建对象
            Student s = new Student();
            s.show();
        }
    }

构造方法的注意事项  
**构造方法的创建 :**

如果没有定义构造方法，系统将给出一个默认的无参数构造方法如果定义了构造方法，系统将不再提供默认的构造方法

**推荐的使用方式 :**

无论是否使用，都手动书写无参数构造方法，和带参数构造方法

### 2.继承 ###

#### 继承的实现 ####

*  继承的概念
    
     *  继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
 *  实现继承的格式
    
     *  继承通过extends实现
     *  格式：class 子类 extends 父类 \{ \}
        
         *  举例：class Dog extends Animal \{ \}
 *  继承带来的好处
    
     *  继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
 *  示例代码

public class Fu {
        
        public void show() {
        
            System.out.println("show方法被调用");
        }
    }
    public class Zi extends Fu {
        
        public void method() {
        
            System.out.println("method方法被调用");
        }
    }
    public class Demo {
        
        public static void main(String[] args) {
        
            //创建对象，调用方法
            Fu f = new Fu();
            f.show();
    
            Zi z = new Zi();
            z.method();
            z.show();
        }
    }

#### 继承的好处和弊端 ####

*  继承好处
    
     *  提高了代码的复用性(多个类相同的成员可以放到同一个类中)
     *  提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
 *  继承弊端
    
     *  继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

#### Java中继承的特点 ####

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

public class Granddad {
        
    
        public void drink() {
        
            System.out.println("爷爷爱喝酒");
        }
    
    }
    
    public class Father extends Granddad {
        
    
        public void smoke() {
        
            System.out.println("爸爸爱抽烟");
        }
    
    }
    
    public class Mother {
        
    
        public void dance() {
        
            System.out.println("妈妈爱跳舞");
        }
    
    }
    public class Son extends Father {
        
    	// 此时，Son类中就同时拥有drink方法以及smoke方法
    }

#### this&super关键字 ####

*  this&super关键字：
    
     *  this：代表本类对象的引用
     *  super：代表父类存储空间的标识(可以理解为父类对象引用)
 *  this和super的使用分别
    
     *  成员变量：
        
         *  this.成员变量 - 访问本类成员变量
         *  super.成员变量 - 访问父类成员变量
     *  成员方法：
        
         *  this.成员方法 - 访问本类成员方法
         *  super.成员方法 - 访问父类成员方法
 *  构造方法：
    
     *  this(…) - 访问本类构造方法
     *  super(…) - 访问父类构造方法
    
    #### 继承中构造方法的访问特点 ####
    
    **注意：子类中所有的构造方法默认都会访问父类中无参的构造方法**

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

**问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？**

1. 通过使用super关键字去显示的调用父类的带参构造方法
    2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法
    
    注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

#### 方法重写 ####

*  1、方法重写概念
    
     *  子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
 *  2、方法重写的应用场景
    
     *  当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
 *  3、Override注解
    
     *  用来检测当前的方法，是否是重写的方法，起到【校验】的作用

#### 方法重写的注意事项 ####

1.  私有方法不能被重写(父类私有成员子类是不能继承的)
2.  子类方法访问权限不能更低(public > 默认 > 私有)
3.  静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法

#### 权限修饰符 ####

![在这里插入图片描述][70016d179c204c25a37cbd78b65dd187.png]

#### 抽象类 ####

##### 抽象类的概述 #####

*  1.当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！  
    \- 2.在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

##### 抽象类的特点 #####

*  抽象类和抽象方法必须使用 abstract 关键字修饰
    
        //抽象类的定义
        public abstract class 类名 {
              }
        
        //抽象方法的定义
        public abstract void eat();
 *  抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 *  抽象类不能实例化
 *  抽象类可以有构造方法
 *  抽象类的子类
    
    要么重写抽象类中的所有抽象方法
    
    要么是抽象类

##### 抽象类的案例 #####

*  案例需求
    
    定义猫类(Cat)和狗类(Dog)
    
    猫类成员方法：eat（猫吃鱼）drink（喝水…）
    
    狗类成员方法：eat（狗吃肉）drink（喝水…）
 *  实现步骤
    
    1.  猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
    2.  父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
    3.  抽象方法需要存活在抽象类中，将Animal定义为抽象类
    4.  让 Cat 和 Dog 分别继承 Animal，重写eat方法
    5.  测试类中创建 Cat 和 Dog 对象，调用方法测试
 *  代码实现
    
     *  动物类
    
        public abstract class Animal {
              
            public void drink(){
              
                System.out.println("喝水");
            }
        
            public Animal(){
              
        
            }
        
            public abstract void eat();
        }
    
     *  猫类
    
        public class Cat extends Animal {
              
            @Override
            public void eat() {
              
                System.out.println("猫吃鱼");
            }
        }
    
     *  狗类
    
        public class Dog extends Animal {
              
            @Override
            public void eat() {
              
                System.out.println("狗吃肉");
            }
        }
    
     *  测试类
    
        public static void main(String[] args) {
              
                Dog d = new Dog();
                d.eat();
                d.drink();
        
                Cat c = new Cat();
                c.drink();
                c.eat();
        
                //Animal a = new Animal();
                //a.eat();
            }

#### final ####

*  fianl关键字的作用
    
     *  final代表最终的意思，可以修饰成员方法，成员变量，类
 *  final修饰类、方法、变量的效果
    
     *  fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
     *  final修饰方法：该方法不能被重写
     *  final修饰变量：表明该变量是一个常量，不能再次赋值
        
         *  变量是基本类型,不能改变的是值
         *  变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

### 3.多态 ###

#### 多态的概述 ####

*  什么是多态
    
    同一个对象，在不同时刻表现出来的不同形态
 *  多态的前提
    
     *  要有继承或实现关系
     *  要有方法的重写
     *  要有父类引用指向子类对象
 *  代码演示

class Animal {
        
        public void eat(){
        
            System.out.println("动物吃饭");
        }
    }
    
    class Cat extends Animal {
        
        @Override
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    }
    
    public class Test1Polymorphic {
        
        /*
            多态的前提:
    
                1. 要有(继承 \ 实现)关系
                2. 要有方法重写
                3. 要有父类引用, 指向子类对象
         */
        public static void main(String[] args) {
        
            // 当前事物, 是一只猫
            Cat c = new Cat();
            // 当前事物, 是一只动物
            Animal a = new Cat();
            a.eat();
    
        }
    }

#### 多态中的成员访问特点 ####

*  成员访问特点
    
     *  成员变量
        
        编译看父类，运行看父类
     *  成员方法
        
        编译看父类，运行看子类
 *  代码演示
    
        class Fu {
              
            int num = 10;
        
            public void method(){
              
                System.out.println("Fu.. method");
            }
        }
        
        class Zi extends Fu {
              
            int num = 20;
        
            public void method(){
              
                System.out.println("Zi.. method");
            }
        }
        
        public class Test2Polymorpic {
              
            /*
                 多态的成员访问特点:
        
                        成员变量: 编译看左边 (父类), 运行看左边 (父类)
        
                        成员方法: 编译看左边 (父类), 运行看右边 (子类)
             */
            public static void main(String[] args) {
              
                Fu f = new Zi();
                System.out.println(f.num);
                f.method();
            }
        }

#### 多态的好处和弊端 ####

*  好处
    
    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
 *  弊端
    
    不能使用子类的特有成员

#### 多态中的转型 ####

*  向上转型
    
    父类引用指向子类对象就是向上转型
 *  向下转型
    
    格式：子类型 对象名 = (子类型)父类引用;
 *  代码演示
    
        class Fu {
              
            public void show(){
              
                System.out.println("Fu..show...");
            }
        }
        
        class Zi extends Fu {
              
            @Override
            public void show() {
              
                System.out.println("Zi..show...");
            }
        
            public void method(){
              
                System.out.println("我是子类特有的方法, method");
            }
        }
        
        public class Test3Polymorpic {
              
            public static void main(String[] args) {
              
                // 1. 向上转型 : 父类引用指向子类对象
                Fu f = new Zi();
                f.show();
                // 多态的弊端: 不能调用子类特有的成员
                // f.method();
        
                // A: 直接创建子类对象
                // B: 向下转型
        
                // 2. 向下转型 : 从父类类型, 转换回子类类型
                Zi z = (Zi) f;
                z.method();
            }
        }

#### 多态中转型存在的风险和解决方案 ####

*  风险
    
    如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
 *  解决方案
    
     *  关键字
        
        instanceof
     *  使用格式
        
        变量名 instanceof 类型
        
        通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果
 *  代码演示
    
        abstract class Animal {
              
            public abstract void eat();
        }
        
        class Dog extends Animal {
              
            public void eat() {
              
                System.out.println("狗吃肉");
            }
        
            public void watchHome(){
              
                System.out.println("看家");
            }
        }
        
        class Cat extends Animal {
              
            public void eat() {
              
                System.out.println("猫吃鱼");
            }
        }
        
        public class Test4Polymorpic {
              
            public static void main(String[] args) {
              
                useAnimal(new Dog());
                useAnimal(new Cat());
            }
        
            public static void useAnimal(Animal a){
                // Animal a = new Dog();
                                                     // Animal a = new Cat();
                a.eat();
                //a.watchHome();
        
        //        Dog dog = (Dog) a;
        //        dog.watchHome();  // ClassCastException  类型转换异常
              
                // 判断a变量记录的类型, 是否是Dog
                if(a instanceof Dog){
              
                    Dog dog = (Dog) a;
                    dog.watchHome();
                }
            }
        
        }

[70016d179c204c25a37cbd78b65dd187.png]: https://img-blog.csdnimg.cn/70016d179c204c25a37cbd78b65dd187.png