首页 > 其他分享> 文章详细

day21_内部类丶包装类

2020-09-25 05:04:25 阅读：176 来源： 互联网

标签：String 包装 day21 int println Integer public 内部

内部类

概述：

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
在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
    }
 
}

标签：String,包装,day21,int,println,Integer,public,内部
来源： https://www.cnblogs.com/wurengen/p/13727636.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

day21_内部类丶包装类

内部类

匿名内部类

包装类(Wrapper)

关于包装类使用的面试题