Java第十四天：匿名内部类，String类和IO流

匿名内部类，String类和IO流

1. 匿名内部类

1.1 什么是类的本体

package com.qfedu.a_anonymous;

/**
 * 如果一个类是Abstract修饰的类，类名有两种方式表明
 * Abstract开头，或者Base结尾
 */
abstract class AbstractType {
    abstract public void test();
}

/**
 * 一个普通类继承abstract修饰的类，需要【实现】abstract
 * 类内额所有abstract方法。
 *
 * TypeA是类名，类大括号以内内容都是类的本体
 */
class TypeA extends AbstractType {

    @Override
    public void test() {
        System.out.println("一个普通类继承abstract修饰的类需要完成的方法");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        TypeA a = new TypeA();
        a.test();
    }
}

1.2 abstract抽象类匿名内部类

package com.qfedu.a_anonymous;

/**
 * 如果一个类是Abstract修饰的类，类名有两种方式表明
 * Abstract开头，或者Base结尾
 */
abstract class AbstractType {
    abstract public void test();
}

/**
 * 一个普通类继承abstract修饰的类，需要【实现】abstract
 * 类内额所有abstract方法。
 *
 * TypeA是类名，类大括号以内内容都是类的本体
 */
class TypeA extends AbstractType {

    @Override
    public void test() {
        System.out.println("一个普通类继承abstract修饰的类需要完成的方法");
    }
}

public class Demo1 {
    public static void main(String[] args) {

        /*
        大括号里面的内容都是类的本体，这里是要求一个abstract子类实现的代码块。
        这里有两层含义
            1. 大括号是一个类的本体，只不过没有类名
            2. 大括号里面的内容有且只能是一个abstract类的子类实现的内容
        这就是匿名内部类 Anonymous Inner Type

        new关键字创建的是一个abstract类的子类对象，并且把该对象的空间首地址
        赋值给abstract类引用数据类型的变量，这里隐含一个知识点【多态】

        low
         */
        AbstractType at = new AbstractType() {
            @Override
            public void test() {
                System.out.println("匿名内部类对象调用方法");
            }
        };

        at.test();

        // 匿名内部类的匿名对象直接调用方法 还是有点low
        new AbstractType() {
            @Override
            public void test() {
                System.out.println("匿名内部类的匿名对象直接调用方法");
            }
        }.test();

        // 匿名内部类的匿名对象直接作为方法的参数
        testInnerType(new AbstractType() {
            @Override
            public void test() {
                System.out.println("匿名内部类的匿名对象直接作为方法的参数");
            }
        });
    }

    public static void testInnerType(AbstractType at) {
        at.test();
    }
}

1.3 接口匿名内部类

package com.qfedu.a_anonymous;

interface A {
    void testA();
}

class TypeB implements A {

    @Override
    public void testA() {
        System.out.println("一个类遵从接口实现接口中的成员方法");
    }
}

public class Demo2 {
    public static void main(String[] args) {

        // 匿名内部类对象
        A a = new A() {
            @Override
            public void testA() {
                System.out.println("匿名内部的对象赋值给接口的引用");
            }
        };

        a.testA();


        // 匿名内部类的匿名对象直接调用方法
        new A() {
            @Override
            public void testA() {
                System.out.println("匿名内部类的匿名对象直接调用方法");
            }
        }.testA();

        test(new A() {
            @Override
            public void testA() {
                System.out.println("我小次郎，我武藏，我喵");
            }
        });

        test(() -> System.out.println("匿名内部类的匿名对象作为方法的参数"));
    }

    public static void test(A a) {
        a.testA();
    }
}

2. String类【20遍警告】

2.1 String类字符串比较方式说明

package com.qfedu.b_string;

public class Demo1 {
    public static void main(String[] args) {
        String str1 = "老碗面";
        String str2 = "老碗面";
        String str3 = new String(str1);
        String str4 = new String("老碗面");

        System.out.println(str1 == str2);  // T
        System.out.println(str2 == str3);  // F
        System.out.println(str3 == str4);  // F
        System.out.println(str1 == str4);  // F T

        System.out.println();
        System.out.println(str1.equals(str2));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals(str4));
        System.out.println(str1.equals(str4));
    }
}

2.2 增

+ Java中用于字符串拼接的标记，等价于 concat
String concat(String str);

2.3 删

字符串是一个常量，无法进行删除操作！！！

2.4 改

String replace(char oldChar, char newChar);
// 替换字符串中的所有指定oldChar，使用newChar替换，并返回一个新的字符串

String replaceAll(String oldStr, String newStr);
// 替换字符串中的指定字符序列，使用newStr替换掉

2.5 查

int indexOf(char ch);
int indexOf(String str);
int indexOf(char ch, int fromIndex);
int indexOf(String str, int fromIndex);
// 正序方向找出指定的字符或者字符串，而且可以添加一个限制从哪里开始找【常用】

int lastIdexOf(char ch); // 常用
int lastIndexOf(String str); // 常用
int lastIndexOf(char ch, int fromIndex);
int lastIndexOf(String str, int fromIndex);
// 逆序方向找出指定的字符或者字符串，而且可以添加一个限制从哪里开始找

char charAt(int index);
// 找出指定下标的字符

boolean isEmpty();
// 判断当前字符串是否为空 ""这是空字符串！！！

int length();
// 字符串有效字符个数，字符串长度

boolean contains(String str);
// 判断指定字符是否存在

String substring(int begin);
// 从指定位置开始获取子字符串，直到末尾
String substring(int begin, int end);
// 从指定位置开始，到指定位置结束，获取子字符串，要头不要尾

String[] split(String str);
// 根据指定的字符串切割当前字符串，得到一个字符串数组【重要】

boolean endsWith(String str);
// 判断当前字符串是不是指定字符串结尾

char[] toCharArray();
// 将字符串转换成字符数组

String toUpperCase();
// 转换字符串内的小写字母到大写
String toLowerCase();
// 转换字符串内的大写字母到小写

boolean equalsIgnoreCase(String str);
// 不区分大小写比较字符串！！！

byte[] getBytes();
// 获取当前字符串对应Byte数据类型数组，转成字节形式数组

2.6 转换方法

构造方法：
	String(char[] array);
	// 将指定的字符数组转换成字符串
	String(char[] array, int off, int len);
	// 将指定的字符数组转换成字符串，要求从off位置开始，获取指定len数量的数据

静态成员方法：
	static String valueOf(char[] array);
	static String valueOf(char[] array, int off, int len);	

去空格:
	String trim();
	// 去除字符串两边的空格

3. IO流

3.1 IO分类

IO
	输入输出参照物是当前程序运行使用内存
	Input
		输入
		数据从外部流入内存中，这是输入
	Output
		输出
		数据从内存流入外部，这是输出

处理数据的单位:
	字节
		最常见！！！最常用！！！
	字符
		有且只能处理使用notepad记事本打开的可视化文本文件，能够处理的文件是
		极少数的！！！

类：
	InputStream 字节输入流基类
	--| FileInputStream 文件操作字节输入流
	OutputStream 字节输出流基类
	--| FileoOutputStream 文件操作字节输出流
	
	Reader 字符输入流基类
	--| FileReader 文件操作字符输入流
	Writer 字符输出流基类
	--| FileWriter 文件操作字符输出流

方法:
	read	读取数据
	write	写入数据

3.2 缓冲流

使用缓冲的效率会极大增高！！！
所有的缓冲流都没有任何【读取写入】文件的能力，这里需要对应的字节流或者字符流提供！！！

字节流缓冲[重点]
	BufferedInputStream
		BufferedInputStream(InputStream in)
	BufferedOutputStream
		BufferedOutputStream(OutputStream output)

字符流缓冲
	BufferedReader
		BufferedReader(Reader r);
	BufferedWriter
		BufferedWriter(Writer w);

希望大家关注我一波,防止以后迷路,有需要的可以加我Q讨论互相学习java ,学习路线探讨,经验分享与java Q:2415773436

​