day21_内部类丶包装类

内部类

概述:

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

分类:

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

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

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

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

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

注意

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

如何声明成员内部类 ,格式如下:

day21_内部类丶包装类

访问特点

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

创建内部类对象格式:

day21_内部类丶包装类

代码举例:

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的后面,用其隐含实现一个接口或 实现一个类。

格式:

 day21_内部类丶包装类

匿名内部类的特点

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

对格式“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提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:

                          day21_内部类丶包装类

                                                        day21_内部类丶包装类

装箱与拆箱

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

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

用Integer与 int为例:

day21_内部类丶包装类

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

  • 方式一:直接在数字后加一个空字符串
  • 方式二:通过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类间的转换

day21_内部类丶包装类

关于包装类使用的面试题

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
    }
 
}

 

上一篇:观锁与悲观锁(Hibernate)


下一篇:C语言学习Day21