1.3 面向对象的数据结构表示

目录

1.3.1 💎Java面向对象基础

 1. 类的声明与实例化

2. 类的成员的定义与使用

3. 抽象类

(1). 抽象类及其抽象成员方法必须使用abstract来修饰

(2).抽象类的子类必须使用抽象类的抽象成员方法

4. 泛型类

1.3.2 💎面向对象的抽象数据类型

1.3.3 💎使用Java语言描述数据结构的优势

 1. 使用Java描述数据结构更加简单

2. Java的泛型机制更加适合数据结构的抽象表示

3. java.util提供多种数据结构，可以加速应用系统开发

---

 

1.3.1 💎Java面向对象基础

 1. 类的声明与实例化

[修饰符] class 类名{
    零到多个构造器定义
    零到多个成员变量
    零到多个成员方法
}

修饰符：public，final，abstract（不要修饰符即将修饰符省略也可以）

类名必须是合法的标识符⇦

定义一个圆的类👀：

public class Circle{
    private double radius;
    //构造器
    public Circle(double r){
        radius = r;
    }
}

得到一个半径为2.5的圆☛：

Circle c = new Circle(2.5);

变量c的本质是一个Circle型的变量，是一个半径为2.5的圆的对象

2. 类的成员的定义与使用

类是数据以及数据的操作的封装体🎀，类的成员详细描述了类的数据信息（成员变量）uiji对这些数据信息的操作方法（成员方法）

对上面代码添加方法👀：

//Circle.java
public class Circle{
    private double radius;
    public Circle(double r){
        radius = r;
    }
    //计算圆的周长
    public double getPerimeter(){
        return Math.PI*radius*2;
    }
}

类的成员在类的内部允许直接引用，但在类的外部引用类的成员通常必须使用对象名来引用，格式为➢：📢对象.成员名

public class Test1{
    public static void main(String []args){
        Circle c = new Circle(2.5);
        System.out.println(c.getPerimeter());
    }
}

3. 抽象类

public abstract class Shape{
    public abstract double getPerimeter();
}

(1). 抽象类及其抽象成员方法必须使用abstract来修饰

​
public class Circle extends Shape{
    private double radius;
    public Circle(double e){
        radius = r;
    }
    //重写Shape类计算周长的抽象方法
    public double getPermeter(){
        return Math.PI*radius*2;
    }
}

(2).抽象类的子类必须使用抽象类的抽象成员方法

import javafx.scene.shape.Circle;

public class Triangle extends Shape{
    private double a;
    private double b;
    private double c;
    public Triangle(double a, double b, double c){
        this.a = a;
        this.b = b;
        this.c = c;
    }
    //重写Shape类计算周长的抽象方法
    public double getPerimeter(){
        return a+b+c;
    }
}

//test2.java
public class Text2{
    public static void main(String[] args) {
        Shape s1 = new Triangle(3, 4, 5);
        Shape s2 = new Circle(3.5);
        System.out.println(s1.getPerimeter());
        System.out.println(s2.getPerimeter());
    }
}

4. 泛型类

泛型类就是一种包含了要运算处理的数据的类型尚不明确而临时使用类型参数，来表示一种自定义数据类型

映射Map类👀：

//指定类型参数
public class Map<K, V>{
    //使用类型参数定义成员变量
    K k;
    V v;
    //使用类型参数定义成员方法
    public void set(K key, V value){
        k = key;
        v = value;
    }
    public V get(){
        return v;
    }
}

Map类包含了两个类型参数K和V，K表示键的类型，V表示值的类型，Map类实现由键到值的映射和转换

注意🚩：泛型类在使用时必须明确指定各类型参数对应的实际数据类型，Java编译器在编译代码时将根据所指定的实际数据类型自动替换对应类型参数

eg🍗：

Map<String, String> a = new Map<String, String>();
a.set("China", "中国");
System.out.println(a.get());
Map<Integer, String> b = new Map<Integer, String>();
b.set(21, "10101");
System.out.println(b.get());

上面代码的第一行构造了一个键和值均为String类型的对象a，可实现“China”向“中国”的转换，第四行构造了 一个键为Integer型，值为String型的对象b，可实现十进制21向二进制10101的转换

1.3.2 💎面向对象的抽象数据类型

数据结构研究的是数据对象内部各数据元素之间逻辑关系问题，它不关心数据的具体类型，因此数据结构本身就是一种抽象概念。为了弄清楚针对特定数据结构计算机能进行何种操作，就必须把数据结构中的数据对象、数据关系和基本操作看作一个整体进行定义，从而得到抽象数据类型(Abstract Data Type)
在传统的数据结构教材中，抽象数据类型通常表示为{D,S,P)集合👀

ADT抽象数据类型名{
    数据对象D: <数据对象的定义>;
    数据关系S: <数据关系的定义>;
    基本操作P: <基本操作的定义>;
} ADT抽象数据类型名

• D的定义是在已有数据类型的基础上对新的数据对象的定义
• S的定义描述了数据元素之间的逻辑结构
• P的定义包括操作名称，参数列表，初始条件和操作结果四个部分的定义和描述

📢 基本操作的定义格式为：

<操作名称>([参数列表]);        //前提条件与操作结果描述

eg：♛一个集合的抽象数据类型如下

//用Java泛型类表示的抽象数据类型的格式如下

//数据关系的定义
[访问修饰符] class抽象数据类型名<类型参数列表>{
    [访问修改符] 数据类型 数据对象; //数据对象的定义
    [访问修改符] 返回值类型 基本操作1(参数列表){
        //基本操作1的定义
    }
    //其他基本操作
}



//一个字典的抽象数据类型定义如下

public class Dictionary<K, V>{
    //数据关系的定义：词典是若干个原文词汇及对应的译文词汇所构成的集合
    public K[] keys;
    public V[] values;
    public int n;
    //基本操作：词典提供初始化，添加新词，删除词条，翻译等操作
    public Dictionary (int max){
        //初始化操作的定义
    }
    public void append (K k, V v){
        //添加新词的定义
    }
    public boolean delete (K, K){
        //删除词条的定义
    }
    public V translate(K k){
        //翻译操作的定义
    }
    //其他操作的定义
}

1.3.3 💎使用Java语言描述数据结构的优势

 1. 使用Java描述数据结构更加简单

• 🍭Java语言不使用指针就可以描述数据结构的前驱后继关系
• 🍭Java提供自动的垃圾回收机制

2. Java的泛型机制更加适合数据结构的抽象表示

Java的泛型类定义了一个代码模板，专门针对暂时不确定的数据类型进行抽象描述和定义

🚩在不使用泛型机制描述集合时，必须指定集合元素的数据类型

​
public class Set {
    private final int MaxSize = 20;
    private int[] elements;
    private int length;
    //建立一个空的集合
    public Set(){
        length = 0;
        elements = new int [MaxSize];
    }
    //求集合的长度
    public int Length() {
        return length;
    }
    //向集合中插入一个新元素
    public boolean Insert(int x){
        //具体操作
    }
    //删除集合中的第i个元素
    public boolean Delete(i){
        //具体操作
    }
}

​

上述代码定义了一个整数集合。但在实际应用中集合的数据元素可以是整数，也可以是字符、浮点数或者更复杂的数据。若不借助泛型机制，此时必须反复书写相似的代码，以定义各种集合。

🚩若使用泛型机制，则只需引入一个类型参数T来表示集合元素的数据类型即可完成泛型集合的定义，之后就可以该泛型集合来创建各种类型的集合对象。代码如下所示。

public class Set<T> {
    private final int MaxSize = 20;
    private T[] elements;
    private int length;
    //建立一个空的集合
    public Set(){
        length = 0;
        elements = (T[]) new Object [MaxSize];
        //不能实例化一个泛型对象，所以先实例化一个Object数组，再强制类型转换
    }
    //求集合的长度
    public int Length() {
        return length;
    }
    //向集合中插入一个新元素
    public boolean Insert(T x){
        //具体操作
    }
    //删除集合中的第i个元素
    public boolean Delete(int i){
        //具体操作
    }
}

3. java.util提供多种数据结构，可以加速应用系统开发

java.util包中包括ArrayList，Hashtable，LinkedList，Map，Queue，Set，Stack，TreeSet，Vector等