day21_内部类丶包装类

2024-02-19 10:45:10

内部类

概述：

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
Inner class的名字不能与包含它的外部类类名相同；

分类：

成员内部类（static成员内部类和非static成员内部类）定义在类中方法外的类。
局部内部类（不谈修饰符）、匿名内部类

成员内部类作为类的成员的角色：

和外部类不同，Inner class还可以声明为private或protected；
可以调用外部类的结构
Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

成员内部类作为类的角色：

可以在内部定义属性、方法、构造器等结构
可以声明为abstract类，因此可以被其它的内部类继承
可以声明为final的
编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

注意

非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
成员内部类可以直接使用外部类的所有成员，包括私有的数据
当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

如何声明成员内部类，格式如下：

访问特点

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

创建内部类对象格式：

代码举例：

package demo07;
 
/*
 * 类的内部成员之五：内部类
 * 1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
 *
 * 2.内部类的分类：成员内部类（静态、非静态）  vs 局部内部类(方法内、代码块内、构造器内)
 *
 * 3.成员内部类：
 *         一方面，作为外部类的成员：
 *             >调用外部类的结构
 *             >可以被static修饰
 *             >可以被4种不同的权限修饰
 *
 *         另一方面，作为一个类：
 *             > 类内可以定义属性、方法、构造器等
 *             > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
 *             > 可以被abstract修饰
 *
 *
 *
 */
public class InnerClassTest {
    public static void main(String[] args) {
 
        //创建Dog实例(静态的成员内部类):
        Person.Dog dog = new Person.Dog();
        dog.show();
        //创建Bird实例(非静态的成员内部类):
//        Person.Bird bird = new Person.Bird();//错误的
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();
 
        System.out.println();
 
        bird.display("黄鹂");
 
    }
}
 
 
class Person{
 
    String name = "小明";
    int age;
 
    public void eat(){
        System.out.println("人：吃饭");
    }
 
 
    //静态成员内部类
    static class Dog{
        String name;
        int age;
 
        public void show(){
            System.out.println("卡拉是条狗");
//            eat();
        }
 
    }
    //非静态成员内部类
    class Bird{
        String name = "杜鹃";
 
        public Bird(){
 
        }
 
        public void sing(){
            System.out.println("我是一只小小鸟");
            Person.this.eat();//调用外部类的非静态属性
            eat();
            System.out.println(age);
        }
 
        public void display(String name){
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的属性
            System.out.println(Person.this.name);//外部类的属性
        }
    }
 
 
    public void method(){
        //局部内部类
        class AA{
 
        }
    }
 
    {
        //局部内部类
        class BB{
 
        }
    }
 
    public Person(){
        //局部内部类
        class CC{
 
        }
    }
 
 
 
}

如何使用局部内部类

只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

局部内部类的特点

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
局部内部类可以使用外部类的成员，包括私有的。
局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
局部内部类不能使用static修饰，因此也不能包含静态成员

小节一下类的权限修饰符：

访问权限由大到小，依次是public > protected > (default) > private。定义一个类的时候，权限修饰符规则：

外部类：public / (default)
成员内部类：public / protected / (default) / private
局部内部类：什么都不能写

代码举例：

class Outer {
 
    public void methodOuter() {
        final String name = "张三";
        class Inner { // 局部内部类
            int num = 10;
 
            public void methodInner() {
                System.out.println(num); // 10
                //局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。
                System.out.println(name);
            }
        }
        /*
        如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
       “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
         */
        Inner inner = new Inner();
        inner.methodInner();
    }
 
}

匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

格式：

匿名内部类的特点

匿名内部类必须继承父类或实现接口
匿名内部类只能有一个对象
匿名内部类对象只能使用多态形式引用

对格式“new 接口名称() {...}”进行解析：

new代表创建对象的动作
接口名称就是匿名内部类需要实现哪个接口
{...}这才是匿名内部类的内容

代码举例：

定义接口

package demo05;
 
public interface FlyAble {
 
    void method1(); // 抽象方法
 
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。

/*
    匿名内部类：
        1、什么是内部类？
            内部类：在类的内部又定义了一个新的类。被称为内部类。
        2、内部类的分类：
            静态内部类：类似于静态变量
            实例内部类：类似于实例变量
            局部内部类：类似于局部变量
        3、使用内部类编写的代码，可读性很差。能不用尽量不用。
        4、匿名内部类是局部内部类的一种。
            因为这个类没有名字而得名，叫做匿名内部类。
        
        5、学习匿名内部类主要是让大家以后在阅读别人代码的时候，能够理解。
        并不代表以后都要这样写。因为匿名内部类有两个缺点：
            缺点1：太复杂，太乱，可读性差。
            缺点2：类没有名字，以后想重复使用，不能用。
*/
 
public class DemoMain {
 
    public static void main(String[] args) {
        /*
        1.等号右边:定义并创建该接口的子类对象
        2.等号左边:是多态,接口类型引用指向子类对象
         */
        // 将f传递给showFly方法中\
        showFly(new FlyAble() {
            public void fly() {
                System.out.println("我飞了~~~");
            }
        });
 
    }
 
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

还要注意几点问题：

匿名内部类，在【创建对象】的时候，只能使用唯一一次。如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
匿名对象，在【调用方法】的时候，只能调用唯一一次。如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】强调：匿名内部类和匿名对象不是一回事！！
发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

包装类(Wrapper)

概述 :Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：

基本数据类型转换成字符串

方式一：直接在数字后加一个空字符串
方式二：通过String类静态方法valueOf()

public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2 //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
    }
}

String转换为int

方式一：先将字符串数字转成Integer，再调用valueOf()方法
方式二：通过Integer静态方法parseInt()进行转换

示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2public static int parseInt (String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

案例需求 :有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”

import java.util.Arrays;
 
public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";
        //把字符串中的数字数据存储到一个int类型的数组中
        String[] strArray = s.split(" ");
        //定义一个int数组，把 String[] 数组中的每一个元素存储到 int 数组中
        int[] arr = new int[strArray.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(strArray[i]);
        }
        //对 int 数组进行排序
        Arrays.sort(arr);
        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();
        //输出结果
        System.out.println(result);
    }
 
}

总结：基本类型、包装类与String类间的转换

关于包装类使用的面试题

package demo04;
 
 
import org.junit.Test;
 
/*
 * 关于包装类使用的面试题
 *
 *
 */
public class InterviewTest {
 
    @Test
    public void test1() {
        Object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1);// 1.0
 
    }
 
    @Test
    public void test2() {
        Object o2;
        if (true)
            o2 = new Integer(1);
        else
            o2 = new Double(2.0);
        System.out.println(o2);// 1
 
    }
 
    @Test
    public void test3() {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false
 
        //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
        //保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
        //-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
 
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true
 
        Integer x = 128;//相当于new了一个Integer对象
        Integer y = 128;//相当于new了一个Integer对象
        System.out.println(x == y);//false
    }
 
}

码农公寓

内部类

匿名内部类

包装类(Wrapper)

关于包装类使用的面试题

相关文章