Java零基础学习Day12——面向对象高级2

一.代码块

1.含义

代码块是类的5大成分之一（成员变量、构造器、方法、代码块、内部类）

2.代码块分类

静态代码块：

• 格式：static{ }
• 特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次
• 作用：完成类的初始化，例如：对静态变量的初始化赋值

package com.itheima.code;
//引用Arrays类后续代码就能使用 Arrays 类所提供的各种操作数组的实用方法了。
import java.util.Arrays;

public class CodeDemo1 {
    public static String name ;//静态变量就属于静态资源
    public static String[] cards = new String[54];
    //静态代码块：有static修饰，属于类，与类一起优先加载，自动执行一次
    //基本作用：可以完成对类的静态资源的初始化
    static {  //优先加载
        System.out.println("静态代码块执行了");
        name = "张三";
        cards[0] = "大王";
        cards[1] = "小王";

    }

    public static void main(String[] args) {
        System.out.println("main方法执行了");
        System.out.println(name);
        System.out.println(Arrays.toString(cards));//这里提供了一个数组工具Arrays类，toString()方法，可以将数组转换成字符串
        //不然直接输出数组，会打印其所在地址，不能出现想要的内容
    }
}

实例代码块

• 格式：{ }
• 特点：每次创建对象时，执行实例代码块，并在构造器前执行
• 作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例对象进行初始化赋值

package com.itheima.code;

public class CodeDemo2 {
    private String name;//属于对象的实例资源
    private String[] directions = new String[4];//实例变量
    //实例代码块：无static修饰，属于对象，每次创建对象时，都会优先执行一次
    //基本作用：初始化对象的实例资源
    {
        System.out.println("实例代码块执行了");
        name = "张三";//所有对象的名字都被初始化成张三

        directions[0] = "North";
        directions[1] = "South";
        directions[2] = "East";
        directions[3] = "West";

    }

    public static void main(String[] args) {
        //目标：实例代码块
        System.out.println("main方法执行了");
        new CodeDemo2();
        new CodeDemo2();
        new CodeDemo2();
        new CodeDemo2();
    }
}

二.内部类

1.含义

如果一个类定义在另一个类的内部，这个类就是内部类。

场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个设计成内部类。

public class Car{
    //内部类
    public class Engine{
    }
}

2.成员内部类

就是类中的一个普通成员，类似前面学过的普通的成员变量、成员方法

public class Outer{
    //成员内部类
    public class Inner{

    }
}

创建对象的格式：
外部类名.内部类名 对象名 = new 外部类（...）.new 内部类（...)；
Outer.Inner in = new Outer().new Inner();

成员内部类访问外部类成员的特点（拓展）：

• 成员内部类中可以直接访问外部类的静态成员，也可以直接访问外部类的实例成员
• 成员内部类的实例方法中，可以直接拿到当前寄生的外部类对象：外部类名.this

class People{
    private int hearBeat = 100;

    public class Heart {
        private int hearBeat = 80;

        public void show(){
            int hearBeat = 200;
            System.out.println(heartBeat);//200
            System.out.println(this.heartBeat);//80
            System.out.println(People.this.heartBeat);//100

3.静态内部类

有static修饰的内部类，属于外部类自己持有

public class Outer{
    //静态内部类
    public static class Inner{
    }
}

外部类名.内部类名 对象名 = new 外部类.内部类(...);

Outer.Inner in = new Outer.Inner();

注：外部类的实例成员属于外部类的对象

成员内部类访问外部类成员的特点（拓展）：

• 静态内部中可以直接访问外部类的静态成员
• 静态内部类不可以直接访问外部类的实例成员

4.局部内部类（了解就行，鸡肋语法）

局部内部类是定义在方法中、代码块中、构造器等执行体中。

5.匿名内部类（重点）

1）含义

是一种特殊的内部类

所谓匿名：指的是程序员不需要为这个类声明名字，默认有个隐藏的名字

new 类或接口（参数值...）{  //参数值一般不写
    类体（一般是方法重写）；
}；

new Animal(){
    @Override
    public void cry(){
    }
};

特点：匿名内部类本质是一个子类，并会立即创建出一个子类对象

作用：用于更方便的创建一个子类对象

注：匿名内部类实际上是有名字的吗，外部类名$编号.class

2）匿名内部类的常见使用形式

通常作为一个对象参数传输给方法

需求：学生，老师要参加游泳比赛

public class Teat2{
    public static void main(String[] args){
    //目标：搞清楚匿名内部类的使用形式（语法），通常可以作为一个对象参数传输给方法使用
    //需求：老师，学生参加游泳比赛
    Swim s1 = new Swim(){
    
        @Override
        public void swimming(){
            System.out.println("学生游得快");
        }
    }
    start(s1);
  }


        //设计一个方法，可以接受老师，学生开始比赛
        public static void start(Swim s){//上面的匿名内部类作为对象参数传递给下面
            System.out.println("开始....");
            s.swimming()；
            System.out.println("结果...");
        }
    }

interface Swim{
    void swimming();//游泳方法
}

3）匿名内部类的应用场景

• 调用别人提供的方法实现需求时，这个方法正好可以让我们传输一个匿名内部类对象给其使用
• 使用comparator接口的匿名内部类实现对数组进行排序

三.函数式编程

1.含义

此”函数“类似于数学中的函数（强调做什么），只要输入的数据一致返回的结果也是一致的

eg：

数学中的函数示例：2x + 1

Java中的函数（Lambda表达式）：（x）->2x + 1

2.解决什么问题

使用Lambda函数代替某些匿名内部类对象，从而让程序代码更简洁，可读性更好

3.Lambda

1）认识Lambda

JDK 8 开始新增的一种语法形式，它表示函数

可以用于替代某些匿名内部类对象，从而让程序更简洁，可读性更好

（被重写方法的形参列表）->{
        被重写方法的方法体代码
}

注意：Lambda表达式只能替代函数式接口的匿名内部类！！！

什么是函数式接口：有且仅有一个抽象方法的接口

//函数式接口：只有一个抽象方法的接口
@FunctionalInterface//声明函数式接口的注解，该注解用于约束当前接口必须是函数式接口
interface Swim{
    void swimming();
}

2）Lambda表达式的省略规则

作用：用于进一步简化Lambda表达式的写法

具体规则：

• 参数类型全部可以省略不写
• 如果只有一个参数，参数类型省略的同时"()"也可以省略，但多个参数不能省略"()"
• 如果Lambda表达式只有一行代码，大括号可以不写，同时要省略分号“;” ,如果这行代码是return语句，也必须去掉return

4.方法引用

1）静态方法引用

类名：：静态方法

使用场景：如果某个Lambda表达式里只是调用一个静态方法，并且“->”前后参数的形式一致，就可以使用静态方法引用。

2）实例方法引用

对象名：：实例方法

使用场景：如果某个Lambda表达式里只是通过对象名称调用一个实例方法，并且"->"前后参数的形式一致，就可以使用实例方法引用。

3）特定类的方法引用

特定类的名称：：方法

使用场景：如果某个Lambda表达式只是调用一个特定类型的实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时既可以使用特定类型的方法引用。

4）构造器引用

类名：：new

使用场景：如果某个Lambda表达式只是在创建对象，并且"->"前后参数情况一致，就可以使用构造器引用。

注：以上这些都是辅助我们在未来的时候能看懂别人写的代码，很多时候不需要自己来写这些代码，属于可遇不可求，可以在后面的学习中慢慢掌握。

四.常用API

1.String

1）含义

String代表字符串，它的对象可以封装字符串数据，并提供很多方法完成对字符串的处理

2）关键做法

创建字符串对象，封装字符串数据

调用String提供的字符串数据的方法

3）方法

方法一：Java程序中的所有字符串文字（例如“abc”）都为此类的对象

String name = "xiaohei";

String school = "heimachengxuyuan"

方法二：调用String类的构造器初始化字符串对象

public String()：创建一个空白字符串对象，不含有任何内容

public String(String original)：根据传入的字符串内容，来创建字符串对象

public String(char[ ] chars)：根据字符数组的内容，来创建字符串对象

public String(byte[ ] bytes)：根据字节数组的内容，来创建字符串对象

注：只有“”给出的字符串对象放在字符串常量池，相同内容只放一个

注：字符串对象的内容比较，千万不要用“==”，因为“==”默认比较地址，字符串对象的内容一样时地址不一定一样。

2.ArrayList

1）含义

集合是一种容器，用来装数据，类似于数组

2）数组和集合的区别

数组定义完成并启动后，长度就固定了

集合大小可变，功能丰富，开发中用的更多

3）关键做法

创建ArrarList对象，代表一个集合容器

调用ArrarList提供的方法，对容器中的数据进行增删改查操作

ArrayList<String> list = new ArrayList<>();//泛型定义集合
//由于Java是强类型语言，所以需要用范式来定义数据类型