java面向对象编程

最新推荐文章于 2024-09-15 09:47:04 发布

Rike_M

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量511

点赞数

文章标签： java 面向对象编程抽象类多态

本文链接：https://blog.csdn.net/Rike_M/article/details/109019431

版权

面向对象总结版

文章目录

面向对象总结版
前言
一、面向对象语言编程
二、抽象类
- 2.1定义
- 2.2抽象类的特点
三、接口
- 3.1 定义
- 3.2 语法规则

前言

Java是一门面向对象的编程语言（OOP），万物皆对象

一、面向对象语言编程

1.1类和对象

类：一类事物的抽象的模板，在现实世界中类就是任意一类事物，在程序中类就是一个描述这类事物的类文件。

对象：在这一类事物中，具体的某一个个体就是对象，在程序中对象就是new出来的有内存空间

1.2类和对象的关系

类和对象的关系：类是抽象的而对象是具体的，对象是由类创建的实例（new出来的）

类的组成（人类）：

类名：给某一类事物取个名字： People

静态的特征称为属性：姓名，年龄，身高，体重（定义变量的语法）

动态的行为称为方法：吃饭，睡觉，打豆豆（方法的定义依然满足之前所学）

类的实现：

在一个类文件（People）中，定义属性和方法

对象的实现

通过类名创建这个类的对象。

注意类名不能直接访问它里面的属性和方法的，必须由类的对象访问
相关实例代码实现

public class People {
    // 定义姓名属性   数据类型 和属性名 = [初始值]
    String name="张三";
    // 定义性别属性
    String sex="男";
    // 定义身高属性
    double height =1.75;
    // 定义体重属性
    double weight = 140;

    /**
     * 定义吃饭的行为（方法）
     */
    public void eat(){
        System.out.println("正在吃饭");
    }

    /**
     * 定义睡觉方法
     */
    public void sleep(){
        System.out.println("正在睡觉");
    }

    /**
     * 定义打豆豆方法
     */
    public void playGame(){
        System.out.println("正在打豆豆");
    }
    // 计算两个数相加
    public int add(int a, int b){
        return a+b;
    }


}
public static void main(String[] args) {
         //  不同通过People直接访问它 需要创建类的实例，也就是对象
        //  创建对象的过程称为类的实例化
        // 语法： 类名  对象名   =  new  类名() ;
        People people = new People();
        // 这时候才可以通过对象名 访问这个对象具有的属性 和 方法
         // 对象名.属性名
        // 对象名.方法名([实参])
        System.out.println("这个对象的属性name ："+ people.name);
        System.out.println("这个对象的属性 sex ：" + people.sex);
        System.out.println("这个对象的属性 weight ："+ people.weight);
        System.out.println("这个对象的属性height："+ people.height);
        // 调用对象的访问
        people.eat();
        people.sleep();
        people.playGame();
       int result =  people.add(2,4);
        System.out.println("这个对象还可以计算 结果："+result);

    }

1.3面向对象的特征

1.4 封装继承多态

封装：

对类中的成员属性进行隐藏（私有化），对类中的成员方法公共。
1.对类的成员属性的封装：

将属性私有化（private），并提供对属性的访问给属性添加共有的gette和setter方法

2.对代码的封装：

为了提高代码的复用性，尽量使用方法和参数传递的方法对代码进行封装，并使该方法公有（public）
代码实现举例：

public class People {
    private String pname;
    private int age;
    private String sex;
    // 提供 getter 和 setter
    public String getPname(){
        return pname;
    }
    public void setPname(String pname){
        this.pname=pname;
    }

    public int getAge(){
        return age;
    }
    public void setAge(int age){
        // 对成员属性的隐蔽性 可以防止随意对属性更改
        if(age>100 || age<0){
            System.out.println("赋值的年龄不合法");
            return;
        }
        this.age = age;
    }

    public String getSex(){
        return sex;
    }
    public void setSex(String sex){
        this.sex= sex;
    }


    // 通常为了方便给属性赋值，会提供有参构造
    public People(String pname ,int age,String sex){
        this.pname = pname;
        this.age = age;
        this.sex = sex;
    }
    public People(){

    }
 }

封装的优点：

1.良好的封装可以减少类的耦合性（类与类的关联）

2.对类中封装的代码可以自由修改而不会印象其他类

3.最大程度提高类中属性的隐蔽性和对属性的控制

继承：

当多个类中都存在相同的属性和行为时，可以将这些共有的属性和行为定义到一个新的类中，让其他类服用这个新类的属性和行为，这种关系就是继承关系

当满足 XXX是一个XXX的时候，也是继承关系，例如苹果是一种水果，其中水果就是父类，苹果就是子类，水果有多种水果，而苹果只是水果的一种，所以苹果继承水果

其中被继承的类是父类（超类，基类），继承父类的类就是子类（新类，派生类）
语法如下：

  public class  父类{
  
  
   }
     public class 子类 extends 父类{
  
  
  }

代码实例

     public Employee(String ename,double sal){
       String ename="王麻子";//员工姓名
    double sal=5000 ; // 员工薪资
    
     public Employee(String ename,double sal){
        this.ename = ename;
        this.sal = sal;
    }
 }
 public class Manager extends Employee{
    // 奖金
    private double comm;
     public Manager(String ename ,double sal ,double comm){
        // 如何覆盖父类的无参构造器 ,手动调用父类的有参构造
        super(ename ,sal);  // 只能写在第一句
        this.comm = comm;
    }
  }

多态：

继Java面向对象中封装，继承之后的第三个特征

同一种行为，具有多个不同的表现形式称为多态
多态的条件：

基于继承关系或基于实现关系的
子类或实现类必须对方法进行重写（没有重写的方法不具有多态行为）
父类的引用指向子类对象（接口的引用指向实现类的对象）


public class People {
    static{
        System.out.println("People的静态语句块");
    }
    public People(){
        System.out.println("People类的无参构造器");
    }
    {
        System.out.println("People的构造语句块");
    }
}

public class Student extends  People{
    static{
        System.out.println("Student 的静态语句块");
    }
    public Student(){
        // 默认调用父类的构造器
        System.out.println("Student的无参构造器");
    }
    {
        System.out.println("Student的构造语句块");
    }
}
public class Pupil extends  Student {
    static{
        System.out.println("Pupil的静态语句块");
    }
    public Pupil(){
        // 调用它父类的无参构造器
        System.out.println("Pupil类的无参构造器");
    }
    {
        System.out.println("pupil的构造器语句块");
    }
}
 public static void main(String[] args) {
          //创建Pupil对象
        Pupil pupil = new Pupil();

    }

多态调用规则：
属性: 当子类和父类中存在相同属性时，以对象的左边引用类型为依据，所谓“看左边”

方法：以当前new出来的对象为依据，如果方法重写了，就调用子类方法，如果方法没有重写调用父类方法

静态方法：无论方法是否有重写，都已对象左边的引用类型为依据。
代码实例：
在这里插入图片描述

结果为：

二、抽象类

2.1定义

在已有类的基础上，由于特殊情况将该类设置为抽象的，这个类就是抽象类

代码如下（示例）：
在这里插入图片描述

2.2抽象类的特点

抽象类不能实例化（不能new），通常抽象被当作父类使用

抽象类中可以有抽象方法（没有方法体的方法）也可以有普通方法

抽象类被当作父类时，它的子类必须重写父类的抽象方法

public abstract class Fruit {
    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    // 水果的甜度  由于不知道是什么水果，所以说过的甜度未知，可以定义为抽象方法
    // 抽象方法
    public abstract void getSweet();

}
public  class Apple extends  Fruit {

    // 子类重写（实现）父类的抽象方法
    @Override
    public void getSweet() {
        System.out.println("这个水果有点甜");
    }
}
public class Lemon extends  Fruit {

    @Override
    public void getSweet() {
        System.out.println("这个水果有点酸，想想都觉得酸");
    }
}
public static void main(String[] args) {
        // 抽象类不能实例化
      //  Fruit fruit = new Fruit();
        // 创建子类对象
        Apple apple = new Apple();
        apple.setColor("红色");
        apple.getSweet();
        System.out.println(apple.getColor());

        Lemon lemon = new Lemon();
        lemon.setColor("黄色");
        lemon.getSweet();
        System.out.println(lemon.getColor());


    }
}

三、接口

3.1 定义

接口用于对某件事物的功能的声明，而没有实现具体功能，接口提供对软件开发的标准规范。

利用接口的“多实现”完成Java的单一继承

3.2 语法规则

public interface 接口名{
      抽象方法定义
}
一个类实现该接口，必须实现接口的所有方法
public class 实现类名  implements 接口名{
     实现接口的所有方法
}

接口的好处：

1、为了规范实现类的行为，让所有的方法都通过接口定义

2、为了提高代码的可扩展性

接口定义实现类的对象和实现类定义试下类的对象的区别?

接口定义实现类的对象只能调用接口中定义的方法，实现类定义的对象既可以调用实现类的方法，也可以调用接口类的方法。