测试开发之java面向对象篇（封装，继承，多态）

我会带着你远行 2023-09-25 12:51 21阅读 0赞

#### Java面向对象：封装、继承、多态 ####

*   *  1. 封装
     *   *  1.1 private关键字
         *  1.2 this关键字
         *  1.3 this内存原理
         *  1.4 封装思想
     *  2. 构造方法
     *   *  2.1 构造方法概述
         *  2.2 构造方法重载
         *  2.3 构造方法特别说明
     *  3. 继承
     *   *  3.1 继承的格式
         *  3.2 继承中的成员方法的访问特点
         *  3.3 继承中的变量访问特点
         *  3.4 super关键字
         *  3.5 继承中的构造方法访问特点
         *  3.6 方法重写
     *  多态
     *   *  4.1 多态的概述
         *  4.2 多态中的成员访问特点
         *  4.3 多态中的转型
     *  抽象
     *   *  5.1 抽象类的特点
         *  5.2 抽象类的成员特点
     *  接口
     *   *  6.1 接口的特点
         *  6.2 接口的成员特点
     *  参数传递
     *   *  7.1 类名作为形参和返回值
         *  7.2 抽象类作为形参和返回值
         *  7.3 接口名作为形参和返回值
     *  内部类
     *   *  8.1 内部类的基本使用
         *  8.2 内部类的访问特点

### 1. 封装 ###

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

*  private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
 *  被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
 *  提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

/*
        学生类
     */
    class Student {
        
        //成员变量
        private String name;
        private int age;
    
        //get/set方法
        public void setName(String n) {
        
            name = n;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setAge(int a) {
        
            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();
    
            //使用set方法给成员变量赋值
            s.setName("林青霞");
            s.setAge(30);
    
            s.show();
    
            //使用get方法获取成员变量的值
            System.out.println(s.getName() + "---" + s.getAge());
            System.out.println(s.getName() + "," + s.getAge());
    
        }
    }

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

*  his修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
 *  方法的形参如果与成员变量同名，不带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.3 this内存原理 ####

*  this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

public class StudentDemo {
        
        public static void main(String[] args) {
        
            Student s1 = new Student();
            s1.setName("林青霞");
            Student s2 = new Student();
            s2.setName("张曼玉");
        }
    }

图文介绍  
![在这里插入图片描述][d33c96042c49456090d83b9fbbaa92e8.png]

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

1.  封装概述

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

1.  封装原则

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

1.  封装好处

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

### 2. 构造方法 ###

#### 2.1 构造方法概述 ####

构造方法是一种特殊的方法  
作用：创建对象 Student stu = new Student();  
格式：  
public class 类名\{

修饰符 类名( 参数 ) \{

\}  
\}  
功能：主要是完成对象数据的初始化

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.2 构造方法重载 ####

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法  
重要功能：可以使用带参构造，为成员变量进行初始化

/*
        学生类
     */
    class Student {
        
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name) {
        
            this.name = name;
        }
    
        public Student(int age) {
        
            this.age = age;
        }
    
        public Student(String name,int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public void show() {
        
            System.out.println(name + "," + age);
        }
    }
    /*
        测试类
     */
    public class StudentDemo {
        
        public static void main(String[] args) {
        
            //创建对象
            Student s1 = new Student();
            s1.show();
    
            //public Student(String name)
            Student s2 = new Student("林青霞");
            s2.show();
    
            //public Student(int age)
            Student s3 = new Student(30);
            s3.show();
    
            //public Student(String name,int age)
            Student s4 = new Student("林青霞",30);
            s4.show();
        }
    }

#### 2.3 构造方法特别说明 ####

new对象并为其成员变量赋值的两种方式

> 1:无参构造方法创建对象后使用setXxx()赋值  
> 2:使用带参构造方法直接创建带有属性值的对象

class Student {
        
        //成员变量
        private String name;
        private int age;
    
        //构造方法
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = 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:无参构造方法创建对象后使用setXxx()赋值
            2:使用带参构造方法直接创建带有属性值的对象
    */
    public class StudentDemo {
        
        public static void main(String[] args) {
        
            //无参构造方法创建对象后使用setXxx()赋值
            Student s1 = new Student();
            s1.setName("林青霞");
            s1.setAge(30);
            s1.show();
    
            //使用带参构造方法直接创建带有属性值的对象
            Student s2 = new Student("林青霞",30);
            s2.show();
        }
    }

### 3. 继承 ###

#### 3.1 继承的格式 ####

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法  
**实现继承的格式**

> 继承通过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();
        }
    }

#### 3.2 继承中的成员方法的访问特点 ####

通过子类对象访问一个方法

子类成员范围找  
父类成员范围找  
如果都没有就报错(不考虑父亲的父亲…)

#### 3.3 继承中的变量访问特点 ####

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找  
子类成员范围找  
父类成员范围找  
如果都没有就报错(不考虑父亲的父亲…)

class Fu {
        
        int num = 10;
    }
    class Zi {
        
        int num = 20;
        public void show(){
        
            int num = 30;
            System.out.println(num);
        }
    }
    public class Demo1 {
        
        public static void main(String[] args) {
        
            Zi z = new Zi();
            z.show();	// 输出show方法中的局部变量30
        }
    }

#### 3.4 super关键字 ####

*  this&super关键字：
    
        this：代表本类对象的引用
          super：代表父类存储空间的标识(可以理解为父类对象引用)
 *  this和super的使用分别
    
        成员变量：
        this.成员变量 - 访问本类成员变量
        super.成员变量 - 访问父类成员变量
        成员方法：
        this.成员方法 - 访问本类成员方法
        super.成员方法 - 访问父类成员方法
        构造方法：
        this(…) - 访问本类构造方法
        super(…) - 访问父类构造方法

#### 3.5 继承中的构造方法访问特点 ####

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()  
**问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？**

1. 通过使用super关键字去显示的调用父类的带参构造方法
    2. 在父类中自己提供一个无参构造方法

**super内存图**  
对象在堆内存中，会单独存在一块super区域，用来存放父类的数据  
![在这里插入图片描述][b51bc1d14b504523ad6426f42597ce2d.png]

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

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()方法被调用");
        }
    }

### 多态 ###

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

*  什么是多态

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

*  多态的前提

要有继承或实现关系  
要有方法的重写  
要有父类引用指向子类对象

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

成员访问特点

成员变量

编译看父类，运行看父类

成员方法

编译看父类，运行看子类

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

public class Cat extends Animal {
        
        public int age = 20;
        public int weight = 10;
    
        @Override
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    
        public void playGame() {
        
            System.out.println("猫捉迷藏");
        }
    }

public class AnimalDemo {
        
        public static void main(String[] args) {
        
            //有父类引用指向子类对象
            Animal a = new Cat();
    
            System.out.println(a.age);
    //        System.out.println(a.weight);
    
            a.eat();
    //        a.playGame();
        }
    }

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

向上转型

父类引用指向子类对象就是向上转型

向下转型

格式：子类型 对象名 = (子类型)父类引用;

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 AnimalDemo {
        
        public static void main(String[] args) {
        
            //多态
            //向上转型
            Animal a = new Cat();
            a.eat();
    //      a.playGame();
    
    
            //向下转型
            Cat c = (Cat)a;
            c.eat();
            c.playGame();
        }
    }

### 抽象 ###

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

当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！  
**抽象类和抽象方法必须使用 abstract 关键字修饰**

//抽象类的定义
    public abstract class 类名 {
        }
    //抽象方法的定义
    public abstract void eat();

> 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
> 
> 抽象类不能实例化
> 
> 抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态
> 
> 抽象类的子类
> 
> 要么重写抽象类中的所有抽象方法
> 
> 要么是抽象类

#### 5.2 抽象类的成员特点 ####

*  成员变量
    
        既可以是变量
        也可以是常量
 *  构造方法
    
        空参构造
        有参构造
 *  成员方法
    
        抽象方法
        普通方法

public abstract class Animal {
        
    
          private int age = 20;
          private final String city = "北京";
      
          public Animal() {
        }
      
          public Animal(int age) {
        
              this.age = age;
          }
      
      
          public void show() {
        
              age = 40;
              System.out.println(age);
              //        city = "上海";
              System.out.println(city);
          }
      
          public abstract void eat();
      }

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

public class AnimalDemo {
        
          public static void main(String[] args) {
        
              Animal a = new Cat();
              a.eat();
              a.show();
          }
      }

### 接口 ###

#### 6.1 接口的特点 ####

使用关键字interface修饰

public interface 接口名 {
        }

类实现接口用implements表示

public class 类名 implements 接口名 {
        }

#### 6.2 接口的成员特点 ####

> 接口不能实例化
> 
> 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
> 
> 多态的形式：具体类多态，抽象类多态，接口多态。
> 
> 接口的子类
> 
> 要么重写接口中的所有抽象方法
> 
> 要么子类也是抽象类

public interface Inter {
        
          public int num = 10;
          public final int num2 = 20;
      //    public static final int num3 = 30;
          int num3 = 30;
      
      //    public Inter() {}
      
      //    public void show() {}
      
          public abstract void method();
          void show();
      
      }

public class InterImpl extends Object implements Inter {
        
          public InterImpl() {
        
              super();
          }
      
          @Override
          public void method() {
        
              System.out.println("method");
          }
      
          @Override
          public void show() {
        
              System.out.println("show");
          }
      }

public class InterfaceDemo {
        
          public static void main(String[] args) {
        
              Inter i = new InterImpl();
      //        i.num = 20;
              System.out.println(i.num);
      //        i.num2 = 40;
              System.out.println(i.num2);
              System.out.println(Inter.num);
          }
      }

### 参数传递 ###

#### 7.1 类名作为形参和返回值 ####

1、类名作为方法的形参

*  方法的形参是类名，其实需要的是该类的对象
 *  实际传递的是该对象的【地址值】

2、类名作为方法的返回值

*  方法的返回值是类名，其实返回的是该类的对象
 *  实际传递的，也是该对象的【地址值】

class Cat {
        
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    }
    class CatOperator {
        
        public void useCat(Cat c) {
         //Cat c = new Cat();
            c.eat();
        }
        public Cat getCat() {
        
            Cat c = new Cat();
            return c;
        }
    }
    public class CatDemo {
        
        public static void main(String[] args) {
        
            //创建操作类对象，并调用方法
            CatOperator co = new CatOperator();
            Cat c = new Cat();
            co.useCat(c);
    
            Cat c2 = co.getCat(); //new Cat()
            c2.eat();
        }
    }

#### 7.2 抽象类作为形参和返回值 ####

抽象类作为形参和返回值

*  方法的形参是抽象类名，其实需要的是该抽象类的子类对象
 *  方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

abstract class Animal {
        
        public abstract void eat();
    }
    class Cat extends Animal {
        
        @Override
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    }
    class AnimalOperator {
        
        public void useAnimal(Animal a) {
         //Animal a = new Cat();
            a.eat();
        }
        public Animal getAnimal() {
        
            Animal a = new Cat();
            return a;
        }
    }
    public class AnimalDemo {
        
        public static void main(String[] args) {
        
            //创建操作类对象，并调用方法
            AnimalOperator ao = new AnimalOperator();
            Animal a = new Cat();
            ao.useAnimal(a);
    
            Animal a2 = ao.getAnimal(); //new Cat()
            a2.eat();
        }
    }

#### 7.3 接口名作为形参和返回值 ####

接口作为形参和返回值

*  方法的形参是接口名，其实需要的是该接口的实现类对象
 *  方法的返回值是接口名，其实返回的是该接口的实现类对象

interface Jumpping {
        
        void jump();
    }
    class JumppingOperator {
        
        public void useJumpping(Jumpping j) {
         //Jumpping j = new Cat();
            j.jump();
        }
        public Jumpping getJumpping() {
        
            Jumpping j = new Cat();
            return j;
        }
    }
    class Cat implements Jumpping {
        
        @Override
        public void jump() {
        
            System.out.println("猫可以跳高了");
        }
    }
    public class JumppingDemo {
        
        public static void main(String[] args) {
        
            //创建操作类对象，并调用方法
            JumppingOperator jo = new JumppingOperator();
            Jumpping j = new Cat();
            jo.useJumpping(j);
    
            Jumpping j2 = jo.getJumpping(); //new Cat()
            j2.jump();
        }
    }

### 内部类 ###

#### 8.1 内部类的基本使用 ####

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

/*
    	格式：
        class 外部类名{
        	修饰符 class 内部类名{
        	
        	}
        }
    */
    
    class Outer {
        
        public class Inner {
        
            
        }
    }

#### 8.2 内部类的访问特点 ####

内部类可以直接访问外部类的成员，包括私有  
外部类要访问内部类的成员，必须创建对象

/*
        内部类访问特点：
            内部类可以直接访问外部类的成员，包括私有
            外部类要访问内部类的成员，必须创建对象
     */
    public class Outer {
        
        private int num = 10;
        public class Inner {
        
            public void show() {
        
                System.out.println(num);
            }
        }
        public void method() {
        
            Inner i = new Inner();
            i.show();
        }
    }

[d33c96042c49456090d83b9fbbaa92e8.png]: https://img-blog.csdnimg.cn/d33c96042c49456090d83b9fbbaa92e8.png
[b51bc1d14b504523ad6426f42597ce2d.png]: https://img-blog.csdnimg.cn/b51bc1d14b504523ad6426f42597ce2d.png