JavaSE基础day11 Jar包、API、匿名内部类、Object、String

---

一.  电脑USB综合案例

定义笔记本类，具备开机，关机和使用USB设备的功能。

笔记本类：包含运行功能、关机功能、使用USB设备功能

USB接口：包含开启功能、关闭功能

鼠标类：要符合USB接口【实现USB】

键盘类：要符合USB接口【实现USB】

 

分析:

1. 定义出一个MacBox 笔记本类, 需要设计出 开机方法openBox, 关机方法 closeBox,

   方法useUSB(可以使用USB设备)

2. 定义出USB接口, 功能就是如何使用USB, 两个方法(抽象方法), openUSB, closeUSB

3. 定义出一个Mouse类, 实现USB接口, 因为鼠标需要符合USB的设计规范, 才能正常使用USB, 重写USB中的两个方法功能openUSB, closeUSB

4. 定义出一个KeyBoard类, 实现USB接口, 因为键盘需要符合USB的设计规范, 才能正常使用USB, 重写USB中的两个方法功能openUSB, closeUSB

5. 定义出一个测试类, 测试鼠标和键盘的使用过程

public interface USB {
    public abstract void openUSB();
    public abstract void closeUSB();
}

public class Mouse implements USB{
    @Override
    public void openUSB() {
        System.out.println("鼠标开始接入USB使用");
    }

    @Override
    public void closeUSB() {
        System.out.println("鼠标使用USB结束,退出");
    }
}

public class Keyboard implements USB{
    @Override
    public void openUSB() {
        System.out.println("键盘开始接入USB使用");
    }

    @Override
    public void closeUSB() {
        System.out.println("键盘使用USB结束,退出");
    }
}

public class MacBook {
    public void open(){
        System.out.println("笔记本开机使用");
    }

    public void close(){
        System.out.println("笔记本关机,结束使用");
    }

    public void useUSB(USB u){// USB u = new Mouse();
       u.openUSB();
       u.closeUSB();
    }
}

public class Test {
    public static void main(String[] args) {
        // 接口多态性 : 父接口引用指向实现类对象
        // 父类引用指向子类对象
        USB u = new Mouse();
        /*u.openUSB();
        USB u1 = new Keyboard();*/

        MacBook m = new MacBook();
        m.open();
        // useUSB方法实际参数提供: 接口的实现类对象,体现出了接口多态性
        m.useUSB(u);

        m.useUSB(new Keyboard());
        m.close();
    }
}

二.  匿名内部类

1、没有名字的内部类

2、匿名内部类的使用前提

        匿名类：继承一个类

       匿名类：实现一个接口

3、格式：

       new 父类类名或者接口名() {

            父类方法的重写或者是接口内容的实现

}

4、本质：

(1) 创建了一个类的子类对象、接口的实现类对象

(2) 更强调关系的一种写法

public class Fu {
    public void fun(){
        System.out.println("我是父类中的fun");
    }
}

public interface MyInterface {
    public abstract void function1();
    public abstract int getSum(int x, int y);
}

public class Demo01_匿名内部类 {
    public static void main(String[] args) {
        /*
           new 父类或者父接口(){// 大括号就是表示这个父类的子类实现过程或者接口的实现类实现过程

           };
           new 关键字创建出一个子类或者实现类对象, ()调用了这个子类或者实现类的空参数构造方法
         */

         new Fu(){
             @Override
             public void fun(){
                 super.fun();
                 System.out.println("我是匿名内部类实现的Fu的子类对象存在");
             }
         }.fun();

         new MyInterface(){
             @Override
             public void function1() {
                 System.out.println("我是function1,重写的");
             }

             @Override
             public int getSum(int x, int y) {
                 return x + y;
             }
         }.function1();

        int result = new MyInterface(){
            @Override
            public void function1() {
                System.out.println("我是function1,重写的");
            }

            @Override
            public int getSum(int x, int y) {
                return x + y;
            }
        }.getSum(4,5);
        System.out.println(result);

        // 为了可以多次调用匿名内部类中继承到的或者是重写的成员(成员变量,方法),可以将匿名变成有名, 利用多态
        MyInterface my = new MyInterface(){
            @Override
            public void function1() {
                System.out.println("我是function1,重写的");
            }

            @Override
            public int getSum(int x, int y) {
                return x + y;
            }
        };

        my.function1();
        System.out.println(my.getSum(6,7));
    }
}

三.  API的使用方式

概述: java的源代码编译之后,形成.class的字节码文件,包含了这个类中的所有内容,因此如果想在脱离源代码的前提下使用.class字节码文件,可以打包生成jar包(在Java中.class字节码文件的标准压缩包就是jar包).

(一)  使用IDEA导出jar包

1. File->Project Structure

或者: 快捷键:ctrl + alt + shift + s

2. 选择 Artifacts -> JAR -> From modules ..

   点一下图中的加号+, 才会出现JAR系列选项

3. 弹出如下消息框

4. 点击上图ok后,回到如下图所示界面:

5. 点击ok前, 先选择apply(应用), 然后点击ok

6. 点击ArrayUtils.jar下的Build. 

7. 显示下图,idea左下角显示已经导出完毕.

种导出方法,导出的是该项目中的所有.class文件

(二)  IDEA导入jar包 

1. 在项目上右键,创建文件夹,并取名为lib,名称可以任意. 

2. 将要导入的jar包复制到该文件夹中.

3. 打开File---Project Structure,选择Modules,选择要进行添加jar包的项目,点击右侧

Dependencies,点击下图所示加号. 

4.选择如图所示:JARs or directories.. 

5. 选择刚才复制的jar包的位置,点击ok.添加完毕.

(三)  删除jar包

仍然选择File--->Project Structure--->Modules,选中jar包,选择减号,移除.再删除lib下的jar包即可.

(四)  API的来源和使用流程

1. 概念:

API（Application Programming Interface，应用程序接口）是一些预先定义的接口

（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定.

用途:

用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节

 

2. 使用流程: 双击打开API

   点击显示,点击索引,在输入框中输入类名.会根据类名的索引进行显示和筛选.双击需要查找的类,右侧会显示该类的详细说明.

  

3. 右侧类的详细说明如下: 

4. 查看构造方法,判断是否可以创建对象

5. 查看每个方法的返回值类型,判断是否是自己需要的方法

6. 查看每个方法是否静态,判断是否可以使用类名直接调用

7. 查看方法名称

8. 查看方法的详细解释和参数列表

(五)  文档注释

1. 文档注释: 以注解的形式描述类或者方法的功能和基本信息, 写在类和方法的声明之上

 /**

    以注解方式描述类或方法的功能

*/

 

2. 常见API注解:

作者：@author lyl

版本：@version v1.0

从哪个版本开始：@since

参数：@param 参数名称 参数名称的解释

返回值：@return 返回内容的解释

/**
 * @author lyl
 * @since 2.0
 * @Version 1.0
 */

    /**
     * 求和
     * @param d1,第一个参数
     * @param d2,第二个参数
     * @return, 两数的和
     */
    public double getSum(double d1, double d2){
        // 描述代码逻辑注释或者是将代码置为无效注释,通常使用单行或者多行注释
        for(; true ;){

        }
        // return d1 + d2;
    }
}

四.  Object类

(一) 概述

1. Object是类层次结构的根类.每个类都使用Object作为超类.所有对象(包括数组)都实现

这个类的方法.随意定义一个类型,不手动显式定义其父类,那么这个类的父类就是Object类.

 

2. 构造方法:

   Object() : 空参构造中,第一行, 没有调用super(), 因为Object没有父类

用途:

(1) 创建Object类的对象的方法.

(2) 子类访问,所有子类都会直接或者间接的访问到这个顶层父类的构造方法.

// Person没有手动的定义任何父类, 那么Object就默认是这个类的父类
public class Person {
}

(二) toString方法

1. public String toString()

返回当前对象的字符串表示.默认Object类的toString方法,由

getClass().getName() + '@' + Integer.toHexString(hashCode())这几部分组成.

(1) getClass().getName() 表示类的完全限定名.

(2) hashCode() 表示根据内存地址通过哈希算法生成的哈希码值.

(3) Integer.toHexString() 表示无符号十六进制的字符串表示形式.

2.对象返回这样一个地址值的字符串,没有什么意义,因此对于子类而言,需要重写父类的这个方法.

3.重写的原则:返回该对象中的所有成员变量的值(对象的属性)

4.快捷键生成:alt + insert -> 点击 toString方法

5.使用打印语句打印一个对象，其实打印的就是这个对象的toString()方法结果.

public class Teacher extends Person{
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class TestObject {
    public static void main(String[] args) {
        Person p = new Person();
        // 1. toString: 在Object类中的源代码, 就是将一个对象的内存地址输出
        //      带有完整包名类名    @    将对象在内存中地址转换成数值
        // return getClass().getName() + "@" + Integer.toHexString(hashCode());
        String str = p.toString();
        System.out.println(str);
        // 2. println: 方法进行对象输出打印时, 默认的调用这个对象的toString方法,打印出对应结果
        System.out.println(p+"----------");

        Teacher t = new Teacher();
        // 3. 对于对象的内存地址,查看没有还说呢么作用的,对于代码来讲, 因此子类需要重写从父类继承到的toString
        // 方法功能: 利用快捷键 alt + insert 自动生成toString, 效果: 查看这个对象在内存中存储的数据
        t.setName("张三");
        t.setAge(19);
        System.out.println(t);
        String s = t.toString();
        System.out.println(s);

        Object obj = new Object();
    }
}

(三) equals方法

1.public boolean equals(Object obj)

　　指示其他某个对象是否与此对象"相等".

2.对于任何非空引用值x和y,当且仅当x和y引用同一个对象时,此方法才返回true(x ==

　　y 具有值true).也就是在Object类型中,比较的是两个引用是否指向了同一个对象.如果

　　是,才返回true.相当于是在比较两个对象的地址值是否相同.

3.实际生活中,比较两个对象的内存地址,没有什么意义.因此在自定义的子类中,都要重

　　写这个方法.

4.重写原则:一般比较两个对象中的所有属性,是否全部相同.

5.快捷键生成:alt + insert -> 点击 equals() and hashCode()方法.

6.==和equals方法的区别:

　　1)比较内容的不同:

　　　　==可以比较任意数据类型,既可以比较基本数据类型,也可以比较引用数据类型.

　　　　equals方法只能比较引用数据类型.

　　2)比较规则不同:

　　　　==在比较基本类型的时候,比较的是数据的值,比较引用类型时,比较的是地址值.

　　　　equals方法在重写之前,比较的是两个对象的地址值,在重写之后,比较的属性值.

import java.util.Objects;
public class Teacher extends Person{
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return age == teacher.age && Objects.equals(name, teacher.name);
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class TestObject {
    public static void main(String[] args) {
        Person p = new Person();
        Person p1 = new Person();
        boolean boo = p.equals(p1);
        System.out.println(boo);// false

        Teacher t = new Teacher();
        t.setName("张三");
        t.setAge(19);
        // 5. 实际开发中, 比较两个对象的内存地址是否相同, 意义不大, 需要比较两个对象成员变量内容是否一致, 需要重写equals方法, alt + insert 快捷键即可
        Teacher t1 = new Teacher();
        t1.setName("张三");
        t1.setAge(19);

        System.out.println(t.equals(t1));// true
    }
}

五.  String类

(一) String类概述

1. String类: 字符串类型,属于java.lang包,使用不需要导包.

2. String类代表字符串.Java程序中的所有字符串字面值(如"abc")都作为此类的实例实现.

3. 在Java中只要使用双引号引用起来的任何数据它们都是String的一个对象.

4. 字符串字面值属于常量,存储在方法区的常量池中,在创建之后就无法更改(是一个不可

变的字符序列).但是它们可以被共享.

5. 字符串在效果上,可以看做是字符数组,但实质上是字节数组.

(二) String类的常用构造方法

public class Demo02_StringConstructor {
    public static void main(String[] args) {
        // 1. String(): 创建出一个空字符串 ""
        String s = new String();
        System.out.println(s + "hello");

        // 2. String(String str): 创建出一个与参数str相同的字符串
        // s1指向是一块堆内存空间
        String s1 = new String("abc");
        // s2指向常量池空间
        String s2 = "abc";
        System.out.println(s1 == s2);// false, 两者地址并不相同

        // 3. String(char[] ch): 将参数ch中的每一个字符获取到,拼接成一个字符串
        char[] ch = {'h','o','你','y','8'};
        String s3 = new String(ch);
        System.out.println(s3);// ho你y8

        // 4. String(char[] ch, int index, int length): 将参数ch数组从index索引位置开始
        // 截取出length个字符,转换成字符串
        String s4 = new String(ch,1,3);
        System.out.println(s4);// o你y

      // 5. String(byte[] b): 将字节数组中的数据参考平台的默认编码表,转换成对应的字符;
        // 将字符拼接成字符串
        byte[] b = {97,98,99,100,101};
        String s5 = new String(b);
        System.out.println(s5);// abcde

        // 6. String(byte[] b, int index, int length):将参数b数组从index索引位置开始
        // 取出length个字节,参考编码表转换成字符, 拼接成字符串
        String s6 = new String(b,0,3);
        System.out.println(s6);// abc
    }
}

(三) 字符串的比较规则

1. public boolean equals(Object anObject):String类重写的方法,判断两个字符串的内容(字符序列)是否相等

2. == : 在比较基本类型的时候,比较的是数据的值,比较引用类型时,比较的是地址值是否相等. 

案例1:

分析以下程序,判断控制台上的输出结果是什么:

String s1 = "abc";

String s2 = "abc";

 

String s3 = new String("abc");

String s4 = new String("abc");

System.out.println(s1 == s2);// true

System.out.println(s3 == s4); // false

System.out.println(s1.equals(s2)); // true

System.out.println(s3.equals(s4)); // true

public class Demo03_StringEquals {
    public static void main(String[] args) {
        String s = "abc";
        String s1 = "abc";
        String s2 = "Abc";
        String s3 = "abc ";
        System.out.println(s.equals(s1));// true
        System.out.println(s.equals(s2));// false
        System.out.println(s1.equals(s3));// false

        String s4 = new String("abc");
        System.out.println(s.equals(s4));// true
    }
}

(四) 字符串的常用方法

1.1 String类的获取和查找功能

1. length() : 获取到一个字符串中的字符个数(字符串的长度) , 返回值类型int

2. charAt(int index): 将字符串中指定的index索引位置上对应的字符获取到,返回值类型char

3. substring(int beginIndex): 截取出字符串的一部分,从beginIndex索引开始, 到最后的全部字符序列取出来, 返回值结果,新的字符串String

4. substring(int beginIndex, int endIndex) : 从beginIndex到endIndex-1之间的字符序列截取成一个新的字符串, 返回值结果String

   注意 : JDK的方法中, 如果是对于两个索引位置进行操作, 通常包括开始索引, 不包括结束索引

5. indexOf(String str) : 获取参数字符串str在方法调用字符串中第一次出现的索引位置

返回值类型int, 如果没有找到参数str存在位置, 返回-1

6. indexOf(String str, int formIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索, 返回值类型int, 如果没有找到参数str存在位置, 返回-1

7. lastIndexOf(String str) : 获取参数字符串str在方法调用字符串中最后一次出现的索引位置

返回值类型int, 如果没有找到参数str存在位置, 返回-1

public class Demo04_StringGet {
    public static void main(String[] args) {
        // 1. length(): 获取字符串长度
        String s = "abc  78";
        System.out.println(s.length());// 7
        System.out.println("".length());// 0

     // 2. charAt(int index) : 将字符串指定索引index位置上的字符获取到, 返回值结果char
        // 注意: 因为字符串底层是一个字符数组, 因此,字符串是有索引位置的, 从0开始, 到length()-1结束
        char ch = s.charAt(6);
        System.out.println(ch);

        System.out.println("-------------------");

        // 3. 结合charAt以及length() 方法, 可以进行字符串的遍历(将字符串中的每一个字符获取到)
        for(int index = 0; index < s.length(); index++){
            System.out.println(s.charAt(index));
        }
        // 4. substring(int index): 将字符串从index索引位置开始, 截取剩下的全部,将截取后的字符串作为
        // 方法的返回值结果, 返回值String
        String s1 = "helloworld";
        String s1New = s1.substring(4);
        System.out.println(s1New);// oworld

        // 5. substring(int beginIndex, int endIndex): 将字符串从beginIndex索引位置开始, 到endIndex-1索引结束, 之间的字符序列截取出字符串, 返回新的字符串 [beginIndex,endIndex)
      // 注意: JDK源代码中,如果一次操作两个索引, 通常包含起始索引而不包含结束索引
        String s2New = s1.substring(2,7);
        System.out.println(s2New);// llowo

    // 6.indexOf(String str) : 获取参数字符串str在方法调用字符串中第一次出现的索引位置
        //返回值类型int, 如果没有找到参数str存在位置, 返回-1
        int index1 = s1.indexOf("wo");
        System.out.println(index1);// 5

        System.out.println(s1.indexOf("l"));// 2
        System.out.println(s1.indexOf("oo"));// -1

     // 7.indexOf(String str, int formIndex):返回在此字符串中第一次出现指定字符处的索引，
       // 从指定的索引开始搜索, 返回值类型int, 如果没有找到参数str存在位置, 返回-1
        System.out.println(s1.indexOf("l",4));// 8

        // 8.lastIndexOf(String str) : 获取参数字符串str在方法调用字符串中最后一次出现的索引位置返回值类型int, 如果没有找到参数str存在位置, 返回-1
        System.out.println(s1.lastIndexOf("o"));// 6
    }
}

1.2 String类中的判断功能

1. equalsIgnoreCase(String anotherString) : 将调用方法字符串与参数列表中的字符串进行内容比较,不考虑字母大小写

2. startsWith(String s) : 调用方法字符串是否以参数s字符串为开始(前缀)

3. endsWith(String s): 调用方法字符串是否以参数s字符串为结束(后缀)

4. isEmpty(): 验证调用方法的字符串是不是一个空字符串””, 如果是空字符串返回true, 否则返回false

public class Demo05_StringPanDuan {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ABc";
        // 1. equalsIgnoreCase(String anotherString) : 将调用方法字符串与参数列表中的字符串进行内容比较,不考虑字母大小写
        // 大小写在java中只有英文字母是有的
        System.out.println(s1.equalsIgnoreCase(s2));// true
        System.out.println("1".equalsIgnoreCase("一"));// false

        // 2. startsWith(String s) : 调用方法字符串是否以参数s字符串为开始(前缀)
        // 需求: 定义出一个人名,问: 人是不是姓李
        String name = "张三";
        //             张三丰
        boolean boo = name.startsWith("李");
        System.out.println(boo);// false
        System.out.println(name.startsWith("张"));//true
        System.out.println(name.startsWith("张三"));//true
        System.out.println(name.startsWith("张三丰"));//false

        System.out.println("----------------------------");

        // 3. endsWith(String s): 调用方法字符串是否以参数s字符串为结束(后缀)
        // 需求: 定义出一个文件名, 问: 文件是不是txt文本文件
        String fileName = "abc.txt";
        //                 abc.txt
        System.out.println(fileName.endsWith("txt"));// true
        System.out.println(fileName.endsWith("tx"));// false
        System.out.println(fileName.endsWith("xt"));// true
        System.out.println(fileName.endsWith("abc.txt"));// true

        // 4. isEmpty(): 验证调用方法的字符串是不是一个空字符串””, 如果是空字符串返回true, 否则返回false
        String s3 = "";
        if(s3.isEmpty()){// ""
            System.out.println("空字符串无序操作");
        }else{
            System.out.println(s3.length());
        }

        if(s3.length() == 0){// ""

        }
    }
}

public class Demo03_StringEquals {
    public static void main(String[] args) {
        String s = "abc";
        String s1 = "abc";
        String s2 = "Abc";
        String s3 = "abc ";
        System.out.println(s.equals(s1));// true
        System.out.println(s.equals(s2));// false
        System.out.println(s1.equals(s3));// false

        String s4 = new String("abc");
        System.out.println(s.equals(s4));// true
    }
}