投稿
  1. 极客之音首页
  2. 后端开发
  3. Java

Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态

飞熊 • • Java • 阅读 193

追求适度，才能走向成功；人在顶峰，迈步就是下坡；身在低谷，抬足既是登高；弦，绷得太紧会断；人，思虑过度会疯；水至清无鱼，人至真无友，山至高无树；适度，不是中庸，而是一种明智的生活态度。

导读：本篇文章讲解 Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

一、Java面对对象的概念：

概念：面向对象程序设计（OOP）是一种程序设计的泛型，同时也是一种程序开发的方法，它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性

Java 类及类的成员
属性（成员变量）
行为（行为方法）
构造器

面向对象的三大特征
封装（encapsulation）
继承（inheritance）
多态（Polymorphism）

其他关键字
this
super
final
static

面向对象的思想概述

  • 面向对象和面向过程的实例 人把大象装进冰箱

    image-20200727162108218

面向对象的思想概述

程序员从面向过程的执行者转换成了面向对象的指挥着。
买内向对象分析方法分析问题的思路和步骤 ：
根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和方法，这些属性和功能就形成了概念世界中的类
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

二、类和对象的基本概念

类：抽象名词，代表一个集合,共性的事物

对象：具象的事物，单个个体

  • 类和对象的关系
    • 对象：代表一类事物的某一个个体
    • 类：代表的是一大类事物

类中的内容，应该具有两个内容

  • 表明事物的特征，是静态属性(变量)
  • 表明事物功能或动作，是动态属性也称方法(函数)

 类：类是现实世界在计算机中的反映，它将数据和对这些数据的操作封装在一起（并没有开空间）

Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态

类的定义

1.定义一个简单的类

Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态

2.类的对象可以直接通过 . 来访问类的公有成员，类的对象指针可以通过->来访问类的公有成员  

类和对象的三种方法

  • 实例方法

    • 需要实例化对象才能使用的方法

  • 静态方法

    • 不需要实例化，通过类直接访问
    • 不使用类或对象的命名空间，其实就是一个函数

  • 类方法

    • 不需要实例化
    • 该方法涉及到操作静态属性(所有对象都拥有的属性)、类方法、静态方法

类的三个访问限定符

1.public：公有的，类的成员可以从类外直接访问

2.private/protected：类的成员不能从类外直接访问

3.类的每个访问限定符可以多次在类中使用，作用域为从该限定符开始到下一个限定符之前/类结束

4.类中如果没有定义限定符，则默认为私有的（private）

三、封装的概念：

封装：是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的好处：只能通过规定方法访问数据

 1.隐藏类的实现细节

 2.方便加入控制语句

 3.方便修改实现

经过封装的属性，不能直接访问，要通过公共属性get/set方法访问。

1.1封装属性

 package com. bai . demo;
//定义了一个规范人信息的类
public class Person {
    //名字
      String  name ;
      //年龄
      private int age;
}

Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态

此时发现了外部程序不能访问age属性了，提示的错误是“这个属性不可见”那么如果一个属性不能访问就失去了本身意义,我们应该为这个封装的属性在内部提供方法(接口)来访问该属性,这样的方法需要两个:一个是取得该属性( getter方法)，另外一个是为该属性赋值(setter 方法)

1.2提供setter和getter方法访问age属性

 package com.bai . demo;
//定义了一个规范人信息的类
public class Person {
    //名字
      String name;
      //年龄
      private int age;
      public void setAge(int myage) {
        age=myage ;
      }
      public int getAge() {
       return   age;
   }
  }

 

 package com. bai . demo;
public class Hello {

 

 public static void main(String[] args) {
    Person per=new Person( ) ;
      Person per=new Person( ) ;
      per. name="李四";
      per. setAge(-10);
      System. out. println("我的名字是:"+per . name) ;
      System. out . print1n("我的年龄是: "+per. getAge());
  }
}

}

Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态

当我们通过方法来访问属性的时候我们可以在方法中做-一些逻辑判断，让数据更完全。比如说我们可以在方法中判断你输入的年龄是否合理。

 1.3 setter 方法中判断年龄

package com. bai . demo;
//定义了一个规范人信息的类
public class Person {
  //名字.
   String   name ;
   //年龄
    private int age;
    public void setAge( int  myage) {
     if(myage<=0||myage>200) {//如果传入 年龄为负数则使用默认值
        age=10;
     }else {
       age=myage;
  }
}
    public int   getAge() {
      return   age ;
  }
}
 


package com. bai . demo ;
public class Hello {
  public static void main(String[] args) {
      Person per=new Person( );
      per. name="李四";
      per.setAge(1000);
      System. out . println("我的名字是: "+per . name);
      System. out. println("我的年龄是: "+per. getAge());
   }
 }

 Java面对对象的概念，类与对象的概念，封装，继承，抽象类，接口，多态

在开发中一个类的属性基本都要封装，尤其是简单Java类(JavaBean)需要封装，封装之后要为封装的属性提供setter个getter方法。

总结:

1、封装的好处:

可以让程序内部结构更安全

可以把重复的代码封装，之后再需要的地方进行调用，在一定程度上解决了代码的重复

2、今天学习的是封装的最小概念(属性的封装)

3、封装的属性要提供setter和getter方法

4、setter 和getter方法的书写规则:

●setter 方法: set+首写字母大写的属性名， 没有返回值(void)，有参数。

●getter 方法: get+首写字母大写的属性名，有返回值，没有参数。

四、继承

继承的概念：所谓的继承就是在原有的代码结构上扩充新的功能，继承解决的是代码的重复的现象

继承的目的：父母的被子女继承，表示父母的归属到子女。

继承的语法:

public class子类 extends 父类{}

继承的机制：首先分析多个类的共同特征，把相同的特征和行为抽离出来形成一个基类，可以让这些类继承基类，而不需要在类本身中再定义相同的属性和行为。

注意：

子类出了可以继承父类的操作还可以扩充自己新的操作，而且子类不能继承父类的构造方法

一个父类可以有多个子类，但是一个子类只能有一个父类

例题：

教师和学生都属于人，他们具有共同的属性：姓名、年龄、性别和身份证号，而学生还具有学号和所学专业两个属性，教师还具有教龄和所教专业两个属性。下面编写 Java 程序代码，使教师（Teacher）类和学生（Student）类都继承于人（People）类，具体的实现步骤如下。

1）创建人类 People，并定义 name、age、sex、sn 属性，代码如下：

public class People {
    public String name; // 姓名
    public int age; // 年龄
    public String sex; // 性别
    public String sn; // 身份证号
    public People(String name, int age, String sex, String sn) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sn = sn;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn;
    }
}

2）创建 People 类的子类 Student 类，并定义 stuNo 和 department 属性，代码如下：

public class Student extends People {
    private String stuNo; // 学号
    private String department; // 所学专业
    public Student(String name, int age, String sex, String sn, String stuno, String department) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.stuNo = stuno;
        this.department = department;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn + "\n学号：" + stuNo + "\n所学专业：" + department;
    }
}

3）创建 People 类的另一个子类 Teacher，并定义 tYear 和 tDept 属性，代码如下：

public class Teacher extends People {
    private int tYear; // 教龄
    private String tDept; // 所教专业
    public Teacher(String name, int age, String sex, String sn, int tYear, String tDept) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.tYear = tYear;
        this.tDept = tDept;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别:" + sex + "\n身份证号：" + sn + "\n教龄：" + tYear + "\n所教专业：" + tDept;
    }
}

 4）编写测试类 PeopleTest，在该类中创建 People 类的不同对象，分别调用它们的 toString() 方法，输出不同的信息。具体的代码如下：

public class PeopleTest {
    public static void main(String[] args) {
        // 创建Student类对象
        People stuPeople = new Student("王丽丽", 23, "女", "410521198902145589", "00001", "计算机应用与技术");
        System.out.println("----------------学生信息---------------------");
        System.out.println(stuPeople);
        // 创建Teacher类对象
        People teaPeople = new Teacher("张文", 30, "男", "410521198203128847", 5, "计算机应用与技术");
        System.out.println("----------------教师信息----------------------");
        System.out.println(teaPeople);
    }
}

 运行程序，输出的结果如下：

----------------学生信息---------------------
姓名：王丽丽
年龄：23
性别：女
身份证号：410521198902145589
学号：00001
所学专业：计算机应用与技术
----------------教师信息----------------------
姓名：张文
年龄：30
性别:男
身份证号：410521198203128847
教龄：5
所教专业：计算机应用与技术

五，抽象类

定义：在Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法称为抽象方法，抽象方法只有方法的声明，没有方法体。

抽象类的特点：

1、抽象类不能被实例化，即不能使用new关键字来实例化对象，只能被继承；

2、包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法；

3、抽象类中的抽象方法的修饰符只能为public或者protected，默认为public；

4、抽象类中的抽象方法只有方法体，没有具体实现；

5、如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；

6、抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化，主要用途是被子类调用。

抽象类和普通类的区别：

1、抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

2、抽象类不能用来创建对象；

3、如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

 六、接口

定义：Java中接口使用interface关键字修饰。接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。

特点:

1、接口可以包含变量、方法；变量被隐士指定为public static final，方法被隐士指定为public abstract（JDK1.8之前）；

2、接口支持多继承，即一个接口可以extends多个接口，间接的解决了Java中类的单继承问题；

3、一个类可以实现多个接口；

4、JDK1.8中对接口增加了新的特性：

4.1、默认方法（default method）：JDK 1.8允许给接口添加非抽象的方法实现，但必须使用default关键字修饰；定义了default的方法可以不被实现子类所实现，但只能被实现子类的对象调用；如果子类实现了多个接口，并且这些接口包含一样的默认方法，则子类必须重写默认方法；

4.2、静态方法（static method）：JDK 1.8中允许使用static关键字修饰一个方法，并提供实现，称为接口静态方法。接口静态方法只能通过接口调用（接口名.静态方法名）。

抽象类和接口的相同点：

1、都不能被实例化2、接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。　

抽象类和接口的区别：

1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。

抽象类和接口的应用场景：

1、有一些方法并且想让它们中的一些有默认实现，就使用抽象类。

2、如果想实现多重继承，就使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。

3、如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

七、多态

定义：多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态，从一定角度来看，封装和继承几乎都是为多态而准备的。

实现多态的步骤：

定义一个父类（Base），实现某个方法（比如：run）
定义多个子类，在子类中重写父类的方法（run）,每个子类run方法实现不同的功能
假设我们定义了一个函数，需要一个Base类型的对象的参数，那么调用函数函数的时候，传入Base类不同的子类对象，那么这个函数就会执行不同的功能，这就是多态的体现

实现多态的必要条件：

  1. 子类必须要继承父类（需要满足继承关系）
  2. 父类引用指向子类引用

需要注意的点：

  1. 父类引用指向子类实例时，可以调用子类重写父类的方法以及直接继承父类的方法，无法调用子类特有的方法
  2. 静态static方法属于特殊情况，静态方法只能继承，不能重写。调用的时候用谁的引用，则调用谁的版本
# 父类
class Animal(object):
    """动物类"""

    def func(self):
        print('动物发出了声音')


# 子类继承（Animal）
class Cat(Animal):
    """猫类"""

    def func(self):
        super().func()
        print('我是猫类:喵 喵 喵')


# 子类继承（Animal）
class Dog(Animal):
    """狗类"""

    def func(self):
        super().func()
        print('我是狗类:汪 汪 汪 ')


a = Cat()
b = Dog()
a.func()
b.func()

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/130158.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！