day12-内部类&API

最新推荐文章于 2024-08-23 23:20:17 发布

W_Jackson

最新推荐文章于 2024-08-23 23:20:17 发布

阅读量109

点赞数

分类专栏：日记文章标签： java

本文链接：https://blog.csdn.net/wangyosh/article/details/114505890

版权

日记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

这篇博客介绍了Java中类、抽象类和接口作为方法形参和返回值的用法，以及内部类的四种类型：成员内部类、局部内部类、匿名内部类和接口实现。此外，还展示了Math、System和Object等常用API的使用，包括排序、时间获取和对象方法。最后，讲解了冒泡排序算法和Arrays工具类的应用。

摘要由CSDN通过智能技术生成

1. 形参和返回值

1.1 类名作为形参和返回值

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

Cat.java

package com.itheima_01;

public class Cat {

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

CatOperator.java

package com.itheima_01;

public class CatOperator {

    public void useCat(Cat c) { //Cat c = new Cat();
        c.eat();
    }

    public Cat getCat() {
        Cat c = new Cat();
        return c;
    }
}

CatDemo.java

package com.itheima_01;

/*
    测试类
 */
public class CatDemo {

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

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

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

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

Animal.java

package com.itheima_02;

public abstract class Animal {

    public abstract void eat();
}

AnimalOperator.java

package com.itheima_02;

public class AnimalOperator {

    public void useAnimal(Animal a) { //Animal a = new Cat();
        a.eat();
    }

    public Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }
}

AnimalDemo.java

package com.itheima_02;

/*
    测试类
 */
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()
        a2.eat();
    }
}

Cat.java

package com.itheima_02;

public class Cat extends Animal {

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

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

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

Jumpping.java

package com.itheima_03;

public interface Jumpping {

    void jump();
}

JumppingOperator.java

package com.itheima_03;

public class JumppingOperator {

    public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
        j.jump();
    }

    public Jumpping getJumpping() {
        Jumpping j = new Cat();
        return j;
    }
}

JumppingDemo.java

package com.itheima_03;

/*
    测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.useJumpping(j);

        Jumpping j2 = jo.getJumpping(); //new Cat()
        j2.jump();
    }
}

Cat.java

package com.itheima_03;

public class Cat implements Jumpping {

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

2.内部类

2.1 内部类概述

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

内部类的定义格式

格式：

public class 类名{
修饰符 class 类名{
}
}

范例：

public class Outer {
public class Inner {
}
}

内部类的访问特点

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

Outer.java

package com.itheima_01;
/*
    内部类格式：
        public class 类名{
              修饰符 class 类名{

              }
        }

    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
public class Outer {

    private int num = 10;

    public class Inner {

        public void show() {
            System.out.println(num);
        }

    }

    public void method() {
//        show();

        Inner i = new Inner();
        i.show();
    }
}

2.2 成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式

在类的成员位置：成员内部类
在类的局部位置：局部内部类

成员内部类，外界如何创建对象使用呢？

格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
范例：Outer.Inner oi = new Outer().new Inner();

Outer.java

package com.itheima_02;

public class Outer {

    private int num = 10;

    /*
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    */

    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }

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

InnerDemo.java

package com.itheima_02;
/*
    测试类
 */
public class InnerDemo {
    public static void main(String[] args) {
        //创建内部类对象，并调用方法
//        Inner i = new Inner();

//        Outer.Inner oi = new Outer().new Inner();
//        oi.show();

        Outer o = new Outer();
        o.method();
    }
}

2.3 局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量

Outer.java

package com.itheima_03;

public class Outer {

    private int num = 10;

    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

OuterDemo.java

package com.itheima_03;
/*
    测试类
 */
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

2.4 匿名内部类

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

格式：

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

范例：

new Inter() {
public void show() {
}
}

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

Outer.java

package com.itheima_04;
/*
    前提：
	    存在一个类或者接口
		这里的类可以是具体类也可以是抽象类

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

	本质是什么呢?
	    是一个继承了该类或者实现了该接口的子类匿名对象
 */
public class Outer {

    public void method() {
        /*
        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        */

//        show();

        /*
        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();

        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();
        */

        Inter i = new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };

        i.show();
        i.show();
    }
}

Inter.java

package com.itheima_04;

public interface Inter {

    void show();

}

OuterDemo.java

package com.itheima_04;

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

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

/*

跳高接口

*/

public interface Jumpping {

void jump();

}

/*

接口操作类，里面有一个方法，方法的参数是接口名

*/

public class JumppingOperator {

public void method(Jumpping j) {

j.jump();

}

}

/*

测试类

*/

public class JumppingDemo {

public static void main(String[] args) {

//需求：创建接口操作类的对象，调用method方法

}

}

Jumpping.java

package com.itheima_05;

/*
    跳高接口
 */
public interface Jumpping {

    void jump();
}

JumppingOperator.java

package com.itheima_05;

/*
    接口操作类，里面有一个方法，方法的参数是接口名
 */
public class JumppingOperator {

    public void method(Jumpping j) { //new Cat();   new Dog();
        j.jump();
    }

}

JumppingDemo.java

package com.itheima_05;

/*
    测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);

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

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });

    }
}

Cat.java

package com.itheima_05;

public class Cat implements Jumpping {

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

Dog.java

package com.itheima_05;

public class Dog implements Jumpping {

    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}

3.常用API

3.1Math

3.1.1 Math 类概述

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

没有构造方法，如何使用类中的成员呢？
看类的成员是否都是静态的，如果是，通过类名就可以直接调用

3.1.2 Math 类的常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float 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)

MathDemo.java

package com.itheima;

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

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

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

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

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

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

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

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

3.2 System

3.2.1 System 类概述

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

3.2.2 System 类的常用方法

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)

SystemDemo.java

package com.itheima;

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

        //public static long currentTimeMillis()：返回当前时间(以毫秒为单位)
//        System.out.println(System.currentTimeMillis());

//        System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
}

3.3 Object

3.3.1 Object 类的概述

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

构造方法：public Object()

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

Student.java

package com.itheima_01;

public class Student extends Object {
    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;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

ObjectDemo.java

package com.itheima_01;

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

    看方法源码：选中方法，按下Ctrl+B

    建议所有子类重写此方法：toString()

    怎么重写呢？自动生成即可
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s); //com.itheima_01.Student@3f3afe78
        System.out.println(s.toString()); //com.itheima_01.Student@3f3afe78

        /*
        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.3.2 Object 类的常用方法

方法名	说明
public String toString()	返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(Object obj)	比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

Student.java

package com.itheima_02;

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

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        //this -- s1
        //o -- s2
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o; //student -- s2

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

ObjectDemo(2).java

package com.itheima_02;

/*
    测试类

    public boolean equals(Object obj)：指示一些其他对象是否等于此
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);

        Student s2 = new Student();
        s2.setName("林青霞");
        s2.setAge(30);

        //需求：比较两个对象的内容是否相同
//        System.out.println(s1 == s2);

        System.out.println(s1.equals(s2));

        /*
            public boolean equals(Object obj) {
                //this -- s1
                //obj -- s2
                return (this == obj);
            }
         */

    }
}

3.4 Arrays

3.4.1 冒泡排序

排序：将一组数据按照固定的规则进行排列

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

如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

ArrayDemo.java

package com.itheima_01;

/*
    冒泡排序：
        一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
        依次对所有的数据进行操作，直至所有数据按要求完成排序
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前：" + arrayToString(arr));

        /*
        //第一次比较
        for(int i=0; i<arr.length-1-0; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一次比较后：" + arrayToString(arr));

        //第二次比较
        for(int i=0; i<arr.length-1-1; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二次比较后：" + arrayToString(arr));

        //第三次比较
        for(int i=0; i<arr.length-1-2; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三次比较后：" + arrayToString(arr));

        //第四次比较
        for(int i=0; i<arr.length-1-3; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第四次比较后：" + arrayToString(arr));
        */

        for(int x=0; x<arr.length-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, ...]
    public static 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.4.2 Arrays 类的概述和常用方法

Arrays 类包含用于操作数组的各种方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组

工具类的设计思想：