杨校老师课堂之Java面向对象知识点整理集锦3

杨校老师课堂之Java面向对象知识点整理集锦2：https://developer.aliyun.com/article/1543050

21. 内部类

什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类：

定义在类中方法外的类

 定义格式：

class 外部类 {
    class 内部类{
    }
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，笔记本电脑类 Laptop 中包含主板 类 Mainboard，如此， MainBoard 就可以采用内部类形式来描述，定义在成员位置。

public class Laptop {
    class MainBoard{
 
    }
}public class Laptop {
    class MainBoard{
 
    }
}

访问特点：

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必须要建立内部类的对象。

实例化内部类格式：

/*
    实例化格式：
    外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
 */
public class Laptop {
    class MainBoard{
 
    }
}
class Demo{
    Laptop.MainBoard  lm = new Laptop().new MainBoard();
}

22.String和StringBuffer

String类:

• 查看类

• java.lang.String ：此类不需要导入。

• 查看构造方法

• public String() ：初始化新创建的 String对象，以使其表示空字符序列。

• public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
• public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。

• 构造举例，代码如下：

// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'H', 'e', 'l', 'l', 'o'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 66, 88, 108 };// 注意： 这里数字范围是 { -128 ~ 127，包括0}
String str3 = new String(bytes);

常用方法:

判断功能的方法

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。

public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小 写。

• public boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。

public class Demo {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "HELLO";
        // boolean equals(Object obj):比较字符串的内容是否相同
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2)); // true
        System.out.println(s1.equalsIgnoreCase(s3)); // true
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        //boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。
        System.out.println(s1.contains("-"));   // false
        System.out.println(s2.contains("l"));  // true
        System.out.println(s2.contains("he")) ;// true
        System.out.println(s2.contains("hl")); // false
        System.out.println(s3.contains("."));  // false
    }
}

获取功能的方法

public int length () ：返回此字符串的长度。

public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

public char charAt (int index) ：返回指定索引处的 char值。

• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
• public int lastIndexOf (String str) ：返回指定子字符串最后一次出现在该字符串内的索引。

public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符 串结尾。

public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。[包头不包尾]

public class Demo {
    public static void main(String[] args) {
 
//创建字符串对象
            String s = "helloworld";
// int length():获取字符串的长度，其实也就是字符个数
            System.out.println("字符串s的长度是：" + s.length());// 10
            System.out.println("‐‐‐‐‐‐‐‐");
// String concat (String str):将将指定的字符串连接到该字符串的末尾.
            String s1 = "helloworld";
            String s2 = s1.concat("**Cheer HuaWei");
            System.out.println(s2);// helloworld**Cheer HuaWei
// char charAt(int index):获取指定索引处的字符
            System.out.println(s.charAt(0));
            System.out.println(s.charAt(1));
            System.out.println("‐‐‐‐‐‐‐‐");
// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
            System.out.println(s1.indexOf("l"));
            System.out.println(s1.indexOf("owo"));
            System.out.println(s1.indexOf("ak"));
            System.out.println("‐‐‐‐‐‐‐‐");
// int lastIndexOf(String str):获取str在字符串对象中最后一次出现的索引,没有返回‐1
            System.out.println(s1.indexOf("l"));
            System.out.println(s1.indexOf("owo"));
            System.out.println(s1.indexOf("ak"));
            System.out.println("‐‐‐‐‐‐‐‐");
// String substring(int start):从start开始截取字符串到字符串结尾
            System.out.println(s.substring(0));
            System.out.println(s.substring(5));
            System.out.println("‐‐‐‐‐‐‐‐");
// String substring(int start,int end):从start到end截取字符串。含start，不含end。
            System.out.println(s.substring(0, s.length()));
            System.out.println(s.substring(3,8));
        }
 
        }
}

转换功能的方法

public char[] toCharArray () ：将此字符串转换为新的字符数组。

public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。

public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。

public class Demo {
 
    public static void main(String[] args) {
        //创建字符串对象
        String s = "abcde";
// char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
// byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        for (int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
// 替换字母huawei为大写HuaWei
        String str = "Cheer huawei";
        String replace = str.replace("huawei", "HuaWei");
        System.out.println(replace); // Cheer HuaWei
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }
 
}

• 分割功能的方法

• public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

 public class Demo {
 
    public static void main(String[] args) {
        //创建字符串对象
        String s = "forward:index";
        String[] strArray = s.split(":"); // ["forward","index"]
        System.out.println(strArray.length);// 2
        for(int x = 0; x < strArray.length; x++) {
            System.out.print(strArray[x] + " "); // forward index 
        }
    }
}

StringBuilder类

• 查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

StringBuilder已经覆盖重写了Object当中的toString方法。

构造方法：

• public StringBuilder()：构造一个空的StringBuilder容器。
• public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用带参构造
        StringBuilder sb2 = new StringBuilder("you");
        System.out.println(sb2); // you
    }
}

常用方法：

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象

分别介绍两个方法：

• append方法

• append方法具有多种重载形式，可以接收任意类型的参数。
• 任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。

public class StringBuilderDemo {
  public static void main(String[] args) {
    //创建对象
    StringBuilder builder = new StringBuilder();
    //public StringBuilder append(任意类型)
    StringBuilder builder2 = builder.append("hello");
    //对比一下
    System.out.println("builder:"+builder);
    System.out.println("builder2:"+builder2);
    System.out.println(builder == builder2); //true
      // 可以添加 任何类型
    builder.append("hello");
    builder.append("world");
    builder.append(true);
    builder.append(100);
    // 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
    //链式编程
    builder.append("hello").append("world").append(true).append(100);
    System.out.println("builder:"+builder);
  }
}

• toString方法

• 通过toString方法，StringBuilder对象将会转换为不可变的String对象

public class StringBuilderDemo {
    public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

23.正则表达式

24.System和Runtime类

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

public static long currentTimeMillis()：返回以毫秒为单位的当前时间。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

currentTimeMillis方法

实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

public class Demo {
 
    public static void main(String[] args) throws ParseException {
        //获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1562038452052
    }
}

public class Demo {
 
    /*
        需求： 验证for循环打印数字1-9999所需要使用的时间（毫秒）
     */
    public static void main(String[] args) throws ParseException {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒：" + (end - start));
    }
}

Runtime类

25.Date和DateFormat类

Date类

java.util.Date类 表示特定的瞬间，精确到毫秒

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

提醒：我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

通俗来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

例如

 
import java.util.Date;
 
/*
 * 注意：
 *  在使用println方法时，会自动调用Date类中的toString方法。
 *  Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串
 */
public class Demo {
 
    public static void main(String[] args) {
        // 创建日期对象，把当前的时间
        System.out.println(new Date()); // Tue Jul 02 11:22:10 CST 2019
        // 创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，从Date对象转换为String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。

构造方法：

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。

这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

• public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

• 参数pattern是一个字符串，代表日期时间的自定义格式。

格式规则：

常用的格式规则为：

示例代码：

public class Demo {
 
    public static void main(String[] args) {
        // 对应的日期格式如：2019-07-02 11:28:29
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(format.format(new Date()));// 输出结果：2019-07-02 11:28:29
    }
}

常用方法:

DateFormat类的常用方法有：

• public String format(Date date)：将Date对象格式化为字符串。

• public Date parse(String source)：将字符串解析为Date对象。

26.Math和Random

Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具 类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

基本运算的方法：

• public static double abs(double a) ：返回 double 值的绝对值

double d1 = Math.abs(‐2); //d1的值为2
double d2 = Math.abs(2); //d2的值为2

• public static double ceil(double a) ：返回大于等于参数的最小的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

• public static double floor(double a) ：返回小于等于参数最大的整数

double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(‐3.3); //d2的值为‐4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

• public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

Random类

此类的实例用于生成伪随机数。

Random r = new Random();
int randomNumber = r.nextInt();

• 查看类 java.util.Random ：

• 该类需要 import导入使后使用。

• 查看构造方法 public Random() ：

• 创建一个新的随机数生成器。

• 查看成员方法

• public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n （不包括）之间的 int 值。

使用Random类，完成生成5个20以内的随机整数的操作，代码如下：

//1. 导包
import java.util.Random;
 
public class RandomDemo {
    public static void main(String[] args) {
 
        //2. 创建键盘录入数据的对象
        Random random = new Random();
        for (int i = 0; i < 5; i++) {
            //3. 随机生成一个数据
            int randomNumber = random.nextInt(20);
            //4. 输出数据
            System.out.println("randomNumber:" + randomNumber);
        }
    }
}