初识 API 之 String 、ArrayList-CSDN博客

本文链接：https://blog.csdn.net/qq_42575689/article/details/129603597

文章目录

常用API String类和ArrayList类的使用
- 1. API （全称 Application Programming Interface：应用程序编程接口）

常用API String类和ArrayList类的使用

1. API （全称 Application Programming Interface：应用程序编程接口）

1.1 String是啥？为什么学习String?

String代表字符串对象，可以用来封装字符串数据，并提供了很多操作字符串的方法对其进行处理。

1.1.1 String创建对象封装字符串数据的方式

方式一： Java 程序中的所有字符串文字（例如“abc”）都为此类的对象。 (直接使用双引号“…” 。)

String name = "我不李姐！"

方式二：调用String类的构造器初始化字符串对象。(new String类，调用构造器初始化字符串对象。)

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 10:28
 * @Description:
 */
public class StringDemo1 {
    public static void main(String[] args) {
        //简便字符串的定义
        String a = "abc";
        System.out.println(a);
        System.out.println("电影名称：" + a);

        //String 对象的标准创建方式
        //无参构造方法，会创建一个空白的字符串
        String b = new String();
        System.out.println(b);

        //直接创建并赋值
        String c = new String("小飞棍");
        System.out.println(c);
        System.out.println("电影名称：" + c);

        //一个字符串是由多个字符组成： abc 是 a、b、c 三个字符组成的
        //把一个字符数组中的每个字符都连接起来，作为一个字符串
        char chars[] = {'a','b','c'};
        String d = new String(chars);
        System.out.println(d);

        //把字节数组中每个数字转成ASCII字符，再把字符连接成字符串
        //通过ASCII编码来初始化字符串
        byte bytes[] = {48,97,65};//——>0,a,A
        String e = new String(bytes);
        System.out.println(e);
    }
}

1.1.2 String提供的操作字符串数据的常用方法

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 15:19
 * @Description:
 */
public class StringDemo4 {
    public static void main(String[] args) {
        String a = "12中国12";
        //截取大字符串中一个小字符申，包含头部不包含尾部
        String sub1 = a.substring(2,4);
        System.out.println(sub1);
        //没有传结束下标，则默认截取到字符串末尾
        String sub2 = a.substring(2);
        System.out.println(sub2);
        //replace 查找字符串中所有的并替换
        String b = a.replace("12","**");
        System.out.println(b);
        //只替换第一个
        String c = a.replaceFirst("12","**");
        System.out.println(c);
        // contains是检查字符申中是否包括某
        System.out.println(a.contains("12"));
        // startwith 是判断字符串是否是以某个子字符串开头
        System.out.println(a.startsWith("12中"));
        // endswith 是判断字符中是否是以某个子字符申结尾
        System.out.println(a.endsWith("12"));
        //split 按照分隔符，把大字符串切割成字符串，并组成数组
        String str = "张三、李四、王五";
        String[] split = str.split("、");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
}

运行结果：

1.1.3 String使用时的注意事项

String是不可变字符串对象
只要是以“…”方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份；
但通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。

1.1.3.1 注意事项1

String是不可变字符串对象

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 10:43
 * @Description:
 */
public class StringDemo {
    public static void main(String[] args) {
        String name = "我不";
        name += "李姐";
        name += "!";
        System.out.println(name);
    }
}

运行结果：

name指向的字符串对象确实变了啊，那为何还说String的对象都是不可变字符串对象？

注意：只要是以“…”方式写出的字符串对象，会在堆内存中的字符串常量池中存储。(注：字符串常量池存储所有字面量，有助于节省内存空间！)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A5xY8pts-1678979808502)(C:\Users\RYRH\AppData\Roaming\Typora\typora-user-images\image-20230316105250811.png)]
结论：每次试图改变字符串对象实际上是新产生了新的字符串对象了，变量每次都是指向了新的字符串对象，之前字符串对象的内容确实是没有改变的，因此说String的对象是不可变的。

1.1.3.2 注意事项2

通过”“定义字符串内存原理

通过new构造器得到字符串对象

1.1.3.3 案例说明

转载于【Java面试】new String(“abc”)到底创建了几个对象？_跟着Mic学架构的博客-CSDN博客

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 14:35
 * @Description:
 */
public class StringDemo3 {
    public static void main(String[] args) {
        String a = "123";
        String b = 1 + "23";
        String c = new String("123");
        String d = new String("23");
        String e = "1" + d;
        String f = "1" + "2" + "3";

        //知识点：Javac在编译的时候会自动优化代码(打开.class文件反编译)
        //自动优化代码策略1：把字面量的表达式会自动计算后，再把结果编译
        System.out.println(a == b);//true
        System.out.println(a == c);//false
        //知识点：字符串和变量在做运算时会在堆内存中新开辟一块空间
        System.out.println(a == e);//false
        System.out.println(a == f);//true
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
//class反编译文件
package com.itheama.string;

public class StringDemo3 {
    public StringDemo3() {
    }

    public static void main(String[] args) {
        String a = "123";
        String b = "123";
        String c = new String("123");
        String d = new String("23");
        String e = "1" + d;
        String f = "123";
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println(a == e);
        System.out.println(a == f);
    }
}

运行结果：

1.1.4 String应用案例：用户登录

1.字符串的比较使用比较好吗？为什么？什么时候使用？

不好，对于字符串对象的比较，==比较的是地址，容易出业务bug
基本数据类型的变量或者值应该使用==比较。

2.开发中比较字符串推荐使用什么方式比较？

使用String提供的equals方法，它只关心字符串内容一样就返回true。

3.完成用户登录

需求：系统正确的登录名和密码是：itheima/123456，请在控制台开发一个登录界面，接收用户输入的登录名和密码，判断用户是否登录成功，登录成功后展示：“欢迎进入系统!”，即可停止程序（注意：要求最多给用户三次登录机会）

步骤：

1、开发登录界面，提示用户通过键盘输入登录名和密码。
2、设计一个登录方法，对用户的登录名和密码进行正确性认证。
3、根据登录方法返回的认证结果，判断用户是否登录成功。
4、使用循环控制登录界面最多显示3次。

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 16:00
 * @Description:
 */

import java.util.Scanner;

/**
 * 需求：系统正确的登录名和密码是：itheima/123456，请在控制台开发一个登录界面，
 * 接收用户输入的登录名和密码，判断用户是否登录成功，登录成功后展示：“欢迎进入系统!”，
 * 即可停止程序（注意：要求最多给用户三次登录机会）
 * 步骤：
 * -  1、开发登录界面，提示用户通过键盘输入登录名和密码。
 * -  2、设计一个登录方法，对用户的登录名和密码进行正确性认证。
 * -  3、根据登录方法返回的认证结果，判断用户是否登录成功。
 * -  4、使用循环控制登录界面最多显示3次。
 */
public class LoginDemo5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 3;//允许登录错误次数
        while (true){
            System.out.println("请输入用户登录名：");
            String username = sc.next();
            System.out.println("请输入密码：");
            String password = sc.next();

            if ("itheima".equals(username) && "123456".equals(password)){
                System.out.println("登录成功！欢迎进入系统!");
                break;
            }else {
                if (count==0){
                    System.out.println("用户已锁定！请联系系统管理员进行解锁！");
                    break;
                }
                count--;
                System.out.println("用户名或密码错误！请重新输入，剩余【"+count+"】次机会，输入失败后将锁定用户！");
            }
        }
    }
}

运行结果：
在这里插入图片描述

1.1.5 String应用案例：验证码

1.使用String来开发验证码。

需求：实现随机产生验证码，验证码的每位可能是数字、大写字母、小写字母。

分析：

①设计一个方法，该方法接收一个整型参数，最终要返回对应位数的随机验证码。
②方法内定义2个字符串变量：1个用来记住生成的验证码，1个用来记住要用到的全部字符。
③定义for循环控制生成多少位随机字符，每次得到一个字符范围内的随机索引，根据索引提取该字符，把该字符交给code变量连接起来，循环结束后，在循环外返回code即可。
④主程序中，调用该方法即可得到随机验证码了。

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 16:14
 * @Description:
 */

import java.util.Random;
import java.util.Scanner;

/**
 *1.使用String来开发验证码。
 * - 需求：实现随机产生验证码，验证码的每位可能是数字、大写字母、小写字母。
 * 分析：
 * - ①设计一个方法，该方法接收一个整型参数，最终要返回对应位数的随机验证码。
 * - ②方法内定义2个字符串变量：1个用来记住生成的验证码，1个用来记住要用到的全部字符。
 * - ③定义for循环控制生成多少位随机字符，每次得到一个字符范围内的随机索引，根据索引提取该字符，把该字符交给code变量连接起来，循环结束后，在循环外返回code即可。
 * - ④主程序中，调用该方法即可得到随机验证码了。
 */
public class VerificationCodeDemo6 {
    public static final String numberChar = "0123456789";
    public static final String letterChar = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    public static final String allChar = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入随机验证码的位数：");
        int num = sc.nextInt();
        String verificationCode = getVerificationCode(num);
        System.out.println("随机验证码为：" + verificationCode);
    }

    public static String getVerificationCode(int num){
        String verificationCode = "";
        Random rd = new Random();
        for (int i=0;i<num;i++) {
            int index = rd.nextInt(allChar.length());
            char c = allChar.charAt(index);
            verificationCode += c;
        }
        return verificationCode;
    }
}

运行结果：
在这里插入图片描述

1.2 什么是集合？，有什么特点？

集合是一种容器，用来装数据的，类似于数组。
集合的大小(长度)可变。

1.2.1 有数组，为啥还学习集合？

数组定义完成并启动后，长度就固定了。
集合大小可变，开发中用的更多。

1.2.2 集合的种类

1.2.3 ArrayList是什么? 怎么使用？

ArrayList是集合中最常用的一种，ArrayList是泛型类，可以约束存储的数据类型。
创建对象，调用无参数构造器初始化对象：public ArrayList();
调用相应的增删改查数据的方法

package com.itheama.arraylist;

import java.util.ArrayList;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 16:53
 * @Description:
 */
public class ArrayListDemo1 {
    public static void main(String[] args) {
        //创建一个集合
        // <>里面的内容叫做泛型，泛型是用来约束集合中存储元素的类型的
        ArrayList<Object> list = new ArrayList();
        //添加数据：添加的顺序即为打印的顺序
        list.add("分段锁");
        list.add(121);
        list.add("sd");
        System.out.println(list);

        //add把元素插入到指定下标位置，没有写下标默认添加到末尾
        list.add(1,"小飞棍");
        System.out.println(list);

        System.out.println("-----------集合的大小(长度)-----------");
        //使用下标时，位置不能大于list.size()，否则会报 IndexOutOfBoundsException
        System.out.println(list.size());//4
//        list.add(5,"小飞棍");

        System.out.println("-----------删除指定下标的元素，并返回删除掉的元素-----------");
        // 删除指定下标的元素，并返回删除掉的元素
        System.out.println(list.remove(2));

        System.out.println("-----------删除指定的元素，返回删除是否成功-----------");
        // 删除指定的元素，返回删除是否成功
        System.out.println(list.remove("sd"));

        System.out.println("-----------集合的遍历-----------");
        //集合的遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-----------修改指定下标的元素，返回被修改的元素-----------");
        //修改指定下标的元素，返回被修改的元素
        System.out.println(list.set(0, "小趴菜"));
        System.out.println(list);
    }
}

运行结果：
请添加图片描述

1.2.4 ArrayList的应用案例

1.2.4.1 从集合中遍历元素，并筛选出元素删除它，应该如何操作才能不出bug？

方式一：每次删除一个数据后，索引-1。
方式二：从集合后面遍历然后删除，可以避免漏掉元素。

package com.itheama.arraylist;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 17:03
 * @Description:
 */

import java.util.ArrayList;

/**
 * 从集合中遍历元素，并筛选出元素删除它，应该如何操作才能不出bug？
 * - 方式一：每次删除一个数据后，索引-1。
 * - 方式二：从集合后面遍历然后删除，可以避免漏掉元素。
 */
public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList();
        //添加数据：添加的顺序即为打印的顺序
        list.add("分段锁");
        list.add(121);
        list.add("sd");

        System.out.println(list);
        System.out.println(list.size());
        int index = list.size()-1;//list.remove(i) ——> list.size() 会减1 故不能使用list.size()去循环，需外部定义一个变量记录集合原始长度
        //方式一：每次删除一个数据后，索引-1。
        for (int i = 0; i <= index;index--) {
            System.out.println(i+"："+list.remove(i));
        }
        System.out.println("-----------------------");
        //方式二：从集合后面遍历然后删除，可以避免漏掉元素。
        for (int i = index; i >= 0; i--) {
            System.out.println(i+"："+list.remove(i));
        }
        //方式三：内部提供的删除全部的方法
        list.clear();
        System.out.println(list);
    }
}

1.2.4.2 掌握从容器中找出某些数据并成功删除的技巧

需求：现在假如购物车中存储了如下这些商品：Java入门,宁夏枸杞，黑枸杞，人字拖，特级枸杞，枸杞子。现在用户不想买枸杞了，选择了批量删除，请完成该需求。

分析：

①后台使用ArrayList集合表示购物车，存储这些商品名。
②遍历集合中的每个数据，只要这个数据包含了“枸杞”则删除它。
③输出集合看是否已经成功删除了全部枸杞数据了。

package com.itheama.arraylist;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 20:01
 * @Description:
 */

import java.util.ArrayList;

/**
 * 需求：现在假如购物车中存储了如下这些商品：Java入门,宁夏枸杞，黑枸杞，人字拖，特级枸杞，枸杞子。现在用户不想买枸杞了，选择了批量删除，请完成该需求。
 * 分析：
 * ①后台使用ArrayList集合表示购物车，存储这些商品名。
 * ②遍历集合中的每个数据，只要这个数据包含了“枸杞”则删除它。
 * ③输出集合看是否已经成功删除了全部枸杞数据了。
 */
public class ArrayListDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        String str = "Java入门，宁夏枸杞，黑枸杞，人字拖，特级枸杞，枸杞子";
        for (String s : str.split("，")) {
            list.add(s);
        }
        System.out.println(list);
        int size = list.size()-1;
        for (int i = size; i >= 0; i--) {
            if (list.get(i).contains("枸杞")){
                list.remove(i);
            }
        }
        System.out.println(list);
    }
}

运行结果：
请添加图片描述

1.2.5 ArrayList的综合案例-模仿外卖系统中的商家系统

需求：完成菜品的上架、以及菜品信息浏览功能。
目标：使用所学的ArrayList集合结合面向对象编程实现以上2个需求。

package com.itheama.arraylist;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 20:15
 * @Description:
 */

import java.util.ArrayList;
import java.util.Scanner;

/**
 * ArrayList的综合案例-模仿外卖系统中的商家系统
 * 需求：完成菜品的上架、以及菜品信息浏览功能。
 * 目标 ：使用所学的ArrayList集合结合面向对象编程实现以上2个需求。
 */
public class ArrayListDemo4 {
    Goods goods;
    private static ArrayList<Goods>  goodsList = new ArrayList<>();
    private static ArrayListDemo4 arrayList;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        goodsList.add(new Goods("麻辣小龙虾","1人份","麻辣","龙虾 姜",41.98,63.88));
        goodsList.add(new Goods("香辣烤猪蹄","2人份","香辣","猪蹄 白芝麻",88.9,228.88));
        goodsList.add(new Goods("招牌鸡骨架","4人份","卤香","鸡骨架",98,158));
        while (true){
            System.out.println("*   \t欢迎进入外卖商家系统！  \t*");
            System.out.println("*****************************");
            System.out.println("*\t\t输入1进行商品上架\t\t*");
            System.out.println("*\t\t输入2进行商品下架\t\t*");
            System.out.println("*\t\t输入3下架所有商品\t\t*");
            System.out.println("*\t\t输入4浏览所有商品\t\t*");
            System.out.println("*****************************");
            System.out.println("*\t 输入除上述按键退出系统！\t*");
            int input = sc.nextInt();

            if (input==1){
                System.out.println("请输入商品名称：");
                String name = sc.next();
                System.out.println("请输入商品分量：");
                String weight = sc.next();
                System.out.println("请输入商品味道：");
                String taste = sc.next();
                System.out.println("请输入商品成分：");
                String component = sc.next();
                System.out.println("请输入商品折扣价：");
                double discountPrice = sc.nextDouble();
                System.out.println("请输入商品原价：");
                double originalPrice = sc.nextDouble();
                ArrayListDemo4.getInstance().addGoods(name,weight,taste,component,discountPrice,originalPrice);
                System.out.println("商品上架成功！");
            }else if(input == 2){
                String number = "0123456789";
                System.out.println("请输入商品名称或者商品索引：");
                String str = sc.next();
                if (number.contains(str)){
                    ArrayListDemo4.getInstance().removeGoods(Integer.parseInt(str));
                }else {
                    ArrayListDemo4.getInstance().removeGoods(str);
                }
            }else if(input == 3){
                ArrayListDemo4.getInstance().removeAllGoods();
            }else if (input == 4){
                ArrayListDemo4.getInstance().showAllGoods();
            }else {
                System.out.println("系统已退出！");
                break;
            }
        }

    }

    public  static ArrayListDemo4 getInstance(){
        if (arrayList==null){
            arrayList = new ArrayListDemo4();
        }
        return arrayList;
    }

    //添加菜品
    public boolean addGoods(String name, String weight, String taste, String component, double discountPrice, double originalPrice){
        return goodsList.add(new Goods(name,weight,taste,component,discountPrice,originalPrice));
    }

    //根据菜名移除菜品
    public boolean removeGoods(String name){
        for (int i = 0; i < goodsList.size(); i++) {
            if (goodsList.get(i).getName().equals(name)){
                return goodsList.remove(goodsList.get(i));
            }
        }
        return false;
    }

    //根据索引移除菜品
    public boolean removeGoods(int index){
        try {
            return goodsList.remove(index) != null ? true:false;
        }catch (IndexOutOfBoundsException e){
            System.out.println("传入下标" + index + "越界，实际长为" + (goodsList.size() - 1));
        }
        return false;
    }

    //移除所有菜品
    public void removeAllGoods(){
        goodsList.clear();
    }

    public void showAllGoods(){
        for (int i = 0; i < goodsList.size(); i++) {
            System.out.println(goodsList.get(i).toString());
        }
    }

    public ArrayListDemo4() {
    }

    public ArrayListDemo4(Goods goods) {
        this.goods = goods;
    }

    public Goods getGoods() {
        return goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }
}

class Goods{
    private String name;//名称
    private String weight;//分量
    private String taste;//味道 英/teɪst/ 美/teɪst/    n.味道，滋味；味觉；爱好，兴趣；  v.尝起来；尝出……的味道；尝，品尝
    private String component;//成分 英/kəmˈpəʊnənt/  美/kəmˈpoʊnənt/  n.组成部份，成分，部件  adj.组成的，构成的
    private double discountPrice;//折扣价
    private double originalPrice;//原价
    public Goods() {
    }

    public Goods(String name, String weight, String taste, String component, double discountPrice, double originalPrice) {
        this.name = name;
        this.weight = weight;
        this.taste = taste;
        this.component = component;
        this.discountPrice = discountPrice;
        this.originalPrice = originalPrice;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWeight() {
        return weight;
    }

    public void setWeight(String weight) {
        this.weight = weight;
    }

    public String getTaste() {
        return taste;
    }

    public void setTaste(String taste) {
        this.taste = taste;
    }

    public String getComponent() {
        return component;
    }

    public void setComponent(String component) {
        this.component = component;
    }

    public double getDiscountPrice() {
        return discountPrice;
    }

    public void setDiscountPrice(double discountPrice) {
        this.discountPrice = discountPrice;
    }

    public double getOriginalPrice() {
        return originalPrice;
    }

    public void setOriginalPrice(double originalPrice) {
        this.originalPrice = originalPrice;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "食品名称='" + name + '\'' +
                ", 分量='" + weight + '\'' +
                ", 味道='" + taste + '\'' +
                ", 成分='" + component + '\'' +
                ", 折扣价='" + discountPrice + '\'' +
                ", 原价='" + originalPrice + '\'' +
                '}';
    }
}

运行结果：未截全
请添加图片描述

1.3 数组和集合的区别

数组定义完成并启动后，类型确定、长度固定。
集合大小可变，提供的功能更为丰富，开发中用的更多。

1.4 包的概述

1.4.1 什么是包？

包是用来分门别类的管理各种不同程序的，类似于文件夹，建包有利于程序的管理和维护。
建包的语法格式：package com.itheima.javabean;

1.4.2 在自己程序中调用其他包下的程序的注意事项

总结：（自己包或lang包不用导，其他类需要先导后用，一个类中使用多个相同的类时，只能用import导一个，其他的用全类名进行声明）

如果当前程序中，要调用自己所在包下的其他程序，可以直接调用。（同一个包下的类，互相可以直接调用）

如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包, 才可以访问！导包格式：import 包名.类名;

如果当前程序中，要调用Java提供的程序，也需要先导包才可以使用；但是Java.lang包下的程序是不需要我们导包的，可以直接使用。

如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问。(在一个类中import只能导入一个Api的类，另一个相同名称的Api需要通过全类名(全包名.类名)进行访问使用)

1.4.3 包名命名规范：

包名必须全小写，且名字与名字之间用.隔开

1.4.4 案例

com.itheama.arraylist.Api

package com.itheama.arraylist;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 9:46
 * @Description:
 */
public class Api {
    public void print(){
        System.out.println("com.itheama.arraylist---------Api");
    }
}

com.itheama.string.Api

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 9:45
 * @Description:
 */
public class Api {
    public void print(){
        System.out.println("com.itheama.string---------Api");
    }
}

ApiDemo

package com.itheama.string;

/**
 * @Auther: Yishooo
 * @Date: 2023-3-16 - 03 - 16 - 9:44
 * @Description:
 */

import com.itheama.arraylist.Api;

/**
 * 在一个类中import只能导入一个Api的类，
 * 另一个相同名称的Api需要通过全类名(全包名.类名)进行访问使用
 */
public class ApiDemo {
    public static void main(String[] args) {
        Api a1 = new Api();
        a1.print();

        com.itheama.string.Api a2 = new com.itheama.string.Api();
        a2.print();
    }
}