Java_内部类&API

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java_内部类&API，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12920字，纯文字阅读大概需要19分钟。

内容图文

1. 参数传递

1.1 类名作为形参和返回值

1、类名作为方法的形参

方法的形参是类名，其实需要的是该类的对象

　　实际传递的是该对象的【地址值】

2、类名作为方法的返回值

方法的返回值是类名，其实返回的是该类的对象

　　实际传递的，也是该对象的【地址值】

示例代码：

            class
             Cat {
    
            public
            void
             eat() {
        System.out.println("猫吃鱼");
    }
}

//操作类class CatOperator {
    //1.类名作为方法的形参
    //方法的形参是类名，其实需要的是该类的对象publicvoid useCat(Cat c) { //Cat c = new Cat();        c.eat();
    }

    //2.类名作为方法的返回值
    //方法的返回值是类名，其实返回的是该类的对象public Cat getCat() {
        Cat c = new Cat();
        return c;
    }
}

publicclass CatDemo {
    publicstaticvoid main(String[] args) {
        //创建操作类对象，并调用方法
        CatOperator co = new CatOperator();
        Cat c = new Cat();
        co.useCat(c);

        Cat c2 = co.getCat(); //new Cat()（Cat c2 = new Cat();）        c2.eat();
    }
}

1.2 抽象类作为形参和返回值

抽象类作为形参和返回值

方法的形参是抽象类名，其实需要的是该抽象类的子类对象

方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

示例代码：

            public
            abstract
            class
             Animal {
    
            public
            abstract
            void
             eat();
}

            public
            class Cat extends Animal {
    @Override
    publicvoid eat() {
        System.out.println("猫吃鱼");
    }
}

            public
            class
             AnimalOperator {
    
            //
            方法的形参是抽象类名，其实需要的是该抽象类的子类对象
            public
            void useAnimal(Animal a) { //Animal a = new Cat();        a.eat();
    }

    //方法的返回值是抽象类名，其实返回的是该抽象类的子类对象public Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }
}

            public
            class
             AnimalDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            创建操作类对象，并调用方法
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);

        Animal a2 = ao.getAnimal(); //new Cat()（Animal a2 = new Cat();）        a2.eat();
    }
}

1.3 接口名作为形参和返回值

接口作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回的是该接口的实现类对象

示例代码：

            public
            interface
             Jumping {
    
            void
             jump();
}

            public
            class Cat implements Jumping {
    @Override
    publicvoid jump() {
        System.out.println("猫跳高了");
    }
}

            public
            class
             JumpingOperator {
    
            public
            void useJumping(Jumping j) { //Jumping j = new Cat();        j.jump();
    }

    public Jumping getJumping() {
        Jumping j = new Cat();
        return j;
    }
}

            public
            class
             JumpingDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            创建操作类对象，并调用方法
        JumpingOperator jo = new JumpingOperator();
        Jumping j = new Cat();
        jo.useJumping(j);

        Jumping j2 = jo.getJumping(); //new Cat()（Jumping j2 = new Cat();）        j2.jump();
    }
}

2. 内部类

2.1 内部类的基本使用

内部类概念：

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类。

            /*
            
    格式：
    class 外部类名 {
        修饰符 class 内部类名 {
            
        }
    }

            */
            class
             Outer {
    
            public
            class
             Inner {
        
    }
}

内部类的访问特点：

　　内部类可以直接访问外部类的成员，包括私有

　　外部类要访问内部类的成员，必须创建对象

示例代码：

            //
            外部类
            public
            class
             Outer {
    
            private
            int num = 10;

    //内部类publicclass Inner {
        publicvoid show() {
            System.out.println(num);
        }
    }

    publicvoid method() {
        Inner i = new Inner();
        i.show();
    }
}

2.2 成员内部类

成员内部类的定义位置：

　　在类中方法，跟成员变量是一个位置

外界创建成员内部类格式：

　　格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;

　　举例：Outer.Inner oi = new Outer().new Inner();

成员内部类的推荐使用方案：

　　将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

示例代码：

            public
            class
             Outer {
    
            private
            int num = 10;

    /*
    //成员内部类
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    */privateclass Inner {
        publicvoid show() {
            System.out.println(num);
        }
    }

    publicvoid method() {
        Inner i = new Inner();
        i.show();
    }
}

            public
            class
             InnerDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            创建内部类对象，并调用方法

            //
                    Inner i = new Inner(); 错误

            //
                    Outer.Inner oi = new Outer().new Inner(); 
            //
            内部类是public修饰才可行

            //
                    oi.show();
            
        Outer o = new Outer();
        o.method();
    }
}

2.3 局部内部类

局部内部类定义位置：

　　局部内部类是在方法中定义的类

局部内部类方式方式：

　　局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

　　该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码：

            public
            class
             Outer {
    
            private
            int num = 10;

    publicvoid method() {
        int num2 = 20;
        //局部内部类(局部内部类是在方法中定义的类)class Inner {
            publicvoid show() {
                //直接访问外部类的成员                System.out.println(num);
                //访问方法内的局部变量                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}

            public
            class
             OuterDemo {
    
            public
            static
            void
             main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

局部内部类的方法调用也是间接调用，通过外部类对象调用它的成员方法，在这个方法内部，创建局部内部类对象来调用方法。

2.4 匿名内部类

匿名内部类的前提：

　　存在一个类或者接口，这里的类可以是具体类也可以是抽象类

匿名内部类的格式：

　　格式：new 类名 ( ) { 重写方法 }; 或 new 接口名 ( ) { 重写方法 };

            new
             类名或接口名() {
    重写方法;
};

例如：

            new
             Inner() {
    
            public
            void
             show() {
    }
};

匿名内部类的本质：

本质：是一个继承了该类或者实现了该接口的子类匿名对象

            public
            class
             Outer {
    
            public
            void
             method() {
        
            //
            匿名内部类本质是一个继承了该类或者实现了该接口的子类匿名对象
            /*
             整体可以看做是 Inter的一个实现类对象
        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show(); //直接调用方法
        
            */
            //
            多次调用的话以下方法更好
        Inter i = new Inter() {
            @Override
            publicvoid show() {
                System.out.println("匿名内部类");
            }
        };
        i.show();
        i.show();
    }
}

            public
            interface
             Inter {
    
            void
             show();
}

            public
            class
             OuterDemo {
    
            public
            static
            void
             main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

2.5 匿名内部类在开发中的使用

匿名内部类在开发中的使用：

　　当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

            /*
            
    跳高接口
 
            */
            public
            interface
             Jumping {
    
            void
             jump();
}

            public
            class Cat implements Jumping {
    @Override
    publicvoid jump() {
        System.out.println("猫可以跳高了");
    }
}

            public
            class Dog implements Jumping {
    @Override
    publicvoid jump() {
        System.out.println("狗可以跳高了");
    }
}

            /*
            
    接口操作类，里面有一个方法，方法的参数是接口名
    方法的形参是接口名，其实需要的是该接口的实现类对象
 
            */
            public
            class
             JumpingOperator {
    
            public
            void method(Jumping j) { //new Cat();  new Dog();        j.jump();
    }
}

            public
            class
             JumpingDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            创建接口操作类的对象，调用method方法
        JumpingOperator jo = new JumpingOperator();
        Jumping j = new Cat();
        jo.method(j);

        Jumping j2 = new Dog();
        jo.method(j2);
        System.out.println("---------");

        //匿名内部类的简化，即使没有Cat类，下面的语句也可以执行
        jo.method(new Jumping() {
            @Override
            publicvoid jump() {
                System.out.println("猫可以跳高了");
            }
        });

        //匿名内部类的简化
        jo.method(new Jumping() {
            @Override
            publicvoid jump() {
                System.out.println("狗可以跳高了");
            }
        });

        jo.method(new Jumping() {
            @Override
            publicvoid jump() {
                System.out.println("猪可以跳高了");
            }
        });
    }
}

3. 常用API

3.1 Math

1、Math类概述：

　　Math 包含执行基本数字运算的方法

2、Math中方法的调用方式：

　　Math类中无构造方法，但内部的方法都是静态的，则可以通过类名.进行调用

3、Math类的常用方法：

public static int abs(int a)：返回参数的绝对值

public static double ceil(double a)：返回大于或等于参数的最小double值，等于一个整数

public static double ?oor(double a) ：返回小于或等于参数的最大double值，等于一个整数

public static int round(?oat a) ：按照四舍五入返回最接近参数的int

public static int max(int a,int b)：返回两个int值中的较大值

public static int min(int a,int b) ：返回两个int值中的较小值

public static double pow(double a,double b)：返回a的b次幂的值

public static double random()：返回值为double的正值，[0.0,1.0)

示例代码：

            /*
            
    Math类中的常用方法
 
            */
            public
            class
             MathDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            public static int abs(int a)：返回参数的绝对值
        System.out.println(88); //88
        System.out.println(-88); //88
        System.out.println("--------");

        //public static double ceil(double a)：返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.34)); //13.0
        System.out.println(Math.ceil(12.56)); //13.0
        System.out.println("--------");

        //public static double ?oor(double a)：返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(12.34)); //12.0
        System.out.println(Math.floor(12.56)); //12.0
        System.out.println("--------");

        //public static int round(?oat a)：按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.34F)); //12.0
        System.out.println(Math.round(12.56F)); //13.0
        System.out.println("--------");

        //public static int max(int a,int b)：返回两个int值中的较大值
        System.out.println(Math.max(66, 88)); //88
        System.out.println("--------");

        //public static int min(int a,int b)：返回两个int值中的较小值
        System.out.println(Math.min(66, 88)); //66
        System.out.println("--------");

        //public static double pow(double a,double b)：返回a的b次幂的值
        System.out.println(Math.pow(2.0, 3.0)); //8.0
        System.out.println("--------");

        //public static double random()：返回值为double的正值，[0.0,1.0)        System.out.println(Math.random());
        System.out.println(Math.random() * 100);
        System.out.println((int) (Math.random() * 100) + 1); // [1,100]    }
}

3.2 System

System 包含几个有用的类字段和方法，它不能被实例化。

System类的常用方法：

public static void exit(int status)：终止当前运行的Java虚拟机，非零表示异常终止

public static long currentTimeMillis()：返回当前时间(以毫秒为单位)

示例代码：

需求：在控制台输出1-10000，计算这段代码执行了多少毫秒

            public
            class
             SystemDemo01 {
    
            public
            static
            void
             main(String[] args) {
        System.out.println("开始");
        //public static void exit(int status)：终止当前运行的Java虚拟机，非零表示异常终止
        System.exit(0);
        System.out.println("结束");  //不会运行    }
}

            public
            class
             SystemDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            public static long currentTimeMillis()：返回当前时间(以毫秒为单位)
        
            //
            获取开始的时间节点
            long start = System.currentTimeMillis();
        for (int i = 1; i <= 10000; i++) {
            System.out.println(i);
        }
        //获取代码运行结果后的时间节点long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
}

3.3 Object类的toString方法

public String toString()：返回对象的字符串表示形式。建议所有子类重写该方法，自动生成。

Object类概述：

　　Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份。

　　构造方法：public Object()

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？

　　因为它们的顶级父类只有无参构造方法

查看方法源码的方式：

　　选中方法，按下Ctrl + B

重写toString方法的方式：

　　1. Alt + Insert 选择toString

　　2. 在类的空白区域，右键 -> Generate -> 选择toString

toString方法的作用：

　　以良好的格式，更方便的展示对象中的属性值

示例代码：

            package
             day12.API_Object;


            public
            class Student extends Object {
    private String name;
    privateint age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    publicint getAge() {
        return age;
    }

    publicvoid setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

            package
             day12.API_Object;


            /*
            
    Object 是类层次结构的根，每个类都可以将 Object 作为超类。
    所有类都直接或者间接的继承自该类

    查看方法源码的方式:选中方法，按下Ctrl + B

    建议所有子类重写此方法（toString()方法）
    重写方式：自动生成即可
 
            */
            public
            class
             ObjectDemo {
    
            public
            static
            void
             main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);
        System.out.println(s); //重写前，输出：day12.API_Object.Student@7f63425a
        //重写toString()方法后，输出：Student{name=‘张三‘, age=18}
        System.out.println(s.toString()); //day12.API_Object.Student@7f63425a
        //重写toString()方法后，输出：Student{name=‘张三‘, age=18}/*
            public void println(Object x) { //x = s;
            String s = String.valueOf(x);
            synchronized (this) {
                print(s);
                newLine();
            }
        }

            public static String valueOf(Object obj) { //obj = x;
            return (obj == null) ? "null" : obj.toString();
        }

            public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
         */
    }
}

3.4 Object类的equals方法

public boolean equals(Object obj)：比较对象是否相等。默认比较地址，重写可以比较内容，自动生成。

equals方法的作用：

　　用于对象之间的比较，返回true和false的结果

　　举例：s1.equals(s2); （s1和s2是两个对象）

重写equals方法的场景：

　　不希望比较对象的地址值，想要结合对象属性进行比较的时候。

重写equals方法的方式：

　　1. alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，?nish即可

　　2. 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面同上。

示例代码：

            public
            class
             Student {
    
            private
             String name;
    
            private
            int
             age;

    
            public
             Student() {
    }

    
            public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    publicint getAge() {
        return age;
    }

    publicvoid setAge(int age) {
        this.age = age;
    }

    @Override
    publicboolean equals(Object o) {
        //比较地址是否相同，如果相同，直接返回true/*
            this --- s1
            o --- s2
         */if (this == o) returntrue;

        //判断参数是否为null
        //判断两个对象是否来自同一个类if (o == null || getClass() != o.getClass()) returnfalse;

        //向下转型
        Student student = (Student) o; //student = s2;

        //比较年龄是否相同if (age != student.age) returnfalse;

        //比较姓名内容是否相同return name != null ? name.equals(student.name) : student.name == null;
    }
}

            /*
            
    重写equals方法的场景
    不希望比较对象的地址值，想要结合对象属性进行比较的时候。
 
            */
            public
            class
             ObjectDemo_2 {
    
            public
            static
            void
             main(String[] args) {
        Student s1 = new Student();
        s1.setName("李四");
        s1.setAge(28);

        Student s2 = new Student();
        s2.setName("李四");
        s2.setAge(28);

        //需求：比较两个对象的内容是否相等
//        System.out.println(s1 == s2); //false (s1,s2 分别代表两个地址值，比较的不是内容)
        System.out.println(s1.equals(s2)); //false  //重写equals()方法后输出为：true/*
            public boolean equals(Object obj) {
            //this --- s1
            //obj --- s2
            return (this == obj); //比较的是this和obj的地址值即还是比较的s1和s2的地址值
        }

         */
    }
}

3.5 冒泡排序原理

冒泡排序概述：

　　一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序。

如果有n个数据进行排序，总共需要比较n-1次

每一次比较完毕，下一次的比较就会少一个数据参与

3.6 冒泡排序代码实现

代码示例：

            public
            class
             ArrayDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            定义一个数组
            int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前：" + arrayToString(arr));

        //这里减1，是控制每轮比较的次数for (int x = 0; x < arr.length - 1; x++) {
            //-1是为了避免索引越界，-x是为了调高比较效率（即去掉前面已比较完的元素）for (int i = 0; i < arr.length - 1 - x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + arrayToString(arr));
    }

    //把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]publicstatic String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

3.7 Arrays

Arrays的常用方法：

public static String toString(int[] a)：返回指定数组的内容的字符串表示形式

public static void sort(int[] a)：按照数字顺序排列指定的数组

            import
             java.util.Arrays;


            public
            class
             ArraysDemo {
    
            public
            static
            void
             main(String[] args) {
        
            //
            定义一个数组
            int[] arr = {24, 69, 80, 57, 13};

        //public static String toString(int[] a)：返回指定数组的内容的字符串表示形式
        System.out.println("排序前：" + Arrays.toString(arr));

        //public static void sort(int[] a)：按照数字顺序排列指定的数组        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

工具类设计思想：

　　1、构造方法用 private 修饰

　　2、成员用 public static 修饰

原文：https://www.cnblogs.com/may3/p/14477842.html

内容总结

以上是互联网集市为您收集整理的Java_内部类&API全部内容，希望文章能够帮你解决Java_内部类&API所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1090856.html

来源：【匿名】

【上一篇】java第四次作业【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java_内部类&API】教程文章相关的互联网学习教程文章

目录内部类1、内部类概述2、成员内部类（实例内部类、非静态内部类）3、静态内部类4、局部内部类5、匿名内部类内部类1、内部类概述内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。内部类不是在一个java源文件中编写俩个平行的俩个类,而是在一个类的内部再定义另外一个类。我们可以把外边的类称为外部类,在其内部编写的类称为内部类。内部类分为...

Java内部类详解（一）（转自：http://blog.csdn.net/wangpeng047/article/details/12344593）

很多人对于Java内部类（Inner Class）都十分陌生，甚至听都没听过也没有使用过，内部类在Java中其实是比较重要的一块内容，掌握好这门知识对于编程来说，犹如插上一对翅膀。一、概念内部类是指在一个外部类的内部再定义一个类，类名不需要和文件名相同。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后会生成outer.class和outer$inner.class两个类。所以内部类的成员变量、方法名可以和外部类的相同。内部类...

java匿名内部类

show the code ： packagecom.test.jwen.httpApiAuto;publicclassAInter { publicvoidm0(){ System.out.println("1"); } publicstaticvoidmain(String[]args){ newAInter().m0(); newAInter(){ publicvoidm0(){ System.out.println("2"); } }.m0(); }} 匿名内部类，就是没有名字的类，在运行的时候，会提示里面有两个...

IT十八掌作业_java基础第七天_匿名内部类、异常、包和jar

利用白富美接口案例，土豪征婚使用匿名内部类对象实现。2.定义三角形类Trianle,里面包含三个int类型属性，分别表示三条边的长度，构造三角形对象时，任意两边之和是否大于第三边，如若不成立，抛出自定义异常。3.Person类中增加birthday属性，对setBirthday(int ,int , int )方法进行异常处理，要求年有效、月有效、日有效、年月日指定的具体日期有效，对不同情况分别抛出不同的异常。4.将类定义到指定的包下。com.it18zhang,编...

java 泛型深入之Set有用工具各种集合泛型深入使用演示样例，匿名内部类、内部类应用于泛型探讨

java 泛型深入之Set有用工具各种集合泛型深入使用演示样例，匿名内部类、内部类应用于泛型探讨//Sets.java package org.rui.generics.set;import java.util.HashSet; import java.util.Set; /*** 一个Set有用工具* @author lenovo**/ public class Sets {public static<T> Set<T> union(Set<T> a,Set<T> b){Set<T> result=new HashSet<T>(a);result.addAll(b);return result;}//保留同样public static <T> Set<T> intersection(S...

java 内部类如何访问外部类的对象

用this就可以做到实例如下：package innerclass;/** * 内部类如何得到外部类的对象 * * */public class DotThis { public class Inner { //返回外部内的对象 public DotThis outer(){ return DotThis.this; } } public void print(){ System.out.println("Out class"); } /** * 得到内部内的对象 */ public Inner inner(){ return new Inner(); } public static void main(String[] args) { //通过外部类得多内部类 Do...

java内部类【代码】

Java内部类和匿名内部类的用法? ?一、内部类:　(1)内部类的同名方法? ? ? ? 内部类可以调用外部类的方法，如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用（其中OuterClass与MethodName换成实际外部类名及其方法；this为关键字，表示对外部类的引用）；若内部类无同名方法可以直接调用外部类的方法。 ? ? ? ? 但外围类无法直接调用内部类的private方法，外部类同样无法直接调用其它类的private方法。注意：内...

Java中的内部类【代码】

有些时候我们需要在一个类中快速的访问另一个类的某些属性，此时可以使用到内部类。class Outer {private String str1 ;private String str2 ;public Outer(String str1, String str2){this.str1 = str1;this.str2 = str2;}publicclass Inner{public String generateNewString(){return str1 + "" + str2;}}publicvoid printInfo(){String newStr = new Inner().generateNewString();System.out.println(newStr);} } publicclass ...

Java 内部类【代码】

纸上得来终觉浅之前总结了Java的一些类的初始化和其他特性，留些内部类还没有总结，还是不能漏的，下面就总结和实践下Java的内部类：1.内部类的分类1）静态内部类：由Static修饰(之前在讲类的初始化的时候提到过，一般类名是不可以由Static修饰的，但是有特例，这个就是)2）非静态内部类：成员内部类（在总结包的访问权限时，提到过一般类名只能是默认或者public修饰，成员内部类是可以可以由任何修饰符修饰的；上面的静态内部类...

java内部类的定义原则

/*内部类的访问规则：1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this2，外部类要访问内部类，必须建立内部类对象。访问格式：1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式外部类名.内部类名变量名 = 外部类对象.内部类对象; Outer.Inner in = new Outer().new...

深入理解java内部类和匿名内部类

1.如果有人问你在java中接口可以new吗?我想答案应该是yes,实现匿名内部类的时候。http://blog.csdn.net/cntanghai/article/details/60944812.如果有人问你类是否可以被private等修饰,我想答案是yes,内部类的好处之一。1.内部类可以很好的实现隐藏一般的非内部类，是不允许有 private 与protected权限的，但内部类可以2．内部类拥有外围类的所有元素的访问权限3.可是实现多重继承4.可以避免修改接口而实现同一个类中两种同名方法的...

java内部类

成员内部类public class User { private int age=12; // 成员内部类 class In { public void print() { System.out.println(age); } }}public class Test { public static void main(String[] args) { User u=new User(); User.In i=u.new In(); i.print(); }}变量访问public class User { private int age=12; // 成员内部类 class In { private int age = 13; public v...

Java 之 -------------- 内部类详解【图】

java中的内部类，分为内部类，局部内部类，匿名内部类！内部类：顾名思义定义在类的内部的类叫做内部类！局部内部类：定义在局部函数中的类，叫做局部内部类！匿名内部类：没有名字的内部类！玩 android 都知道，android 比较常见匿名内部类！内部类的优点：1 内部类可以直接访问外部类的所有成员！因为，当你调用外部类的时候，却生了 outer.this.成员变量或函数！2 含有静态成员的内部类，必须是静态的！3 内部类...

java学习之匿名内部类

/*匿名内部类 * * 一般用于抽象类和接口 * 因为他们不能实例化对象所以可以通过匿名内部类来帮助他们实例化 * 下面demo是抽象类的例子 * * */abstract class Cat{ abstract public void eat();}public class text1 { public static void main(String [] args) { //用法一 Cat cat=new Cat() { public void eat() { System.out.println("匿名内部类"); } }; cat.eat();原文：https://www.cnblogs.com/jzlzn/p/105028...

Java内部类访问局部变量时的final问题

说先我们来看一段示例代码：01 public void start(int interval,final boolean beep) {0203 // Inner Class04 class TimePrinter implements ActionListener {0506 @Override07 public void actionPerformed(ActionEvent event) {08 Date now = new Date();09 System.out.println(“At the tone, the time is “ + now); 10 if (beep) {11 T...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / Java_内部类&API

Java_内部类&API

内容导读

内容图文

1. 参数传递

1.1 类名作为形参和返回值

1.2 抽象类作为形参和返回值

1.3 接口名作为形参和返回值

2. 内部类

2.1 内部类的基本使用

2.2 成员内部类

2.3 局部内部类

2.4 匿名内部类

2.5 匿名内部类在开发中的使用

3. 常用API

3.1 Math

3.2 System

3.3 Object类的toString方法

3.4 Object类的equals方法

3.5 冒泡排序原理

3.6 冒泡排序代码实现

3.7 Arrays

内容总结

内容备注

内容手机端

【Java_内部类&API】教程文章相关的互联网学习教程文章

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程