内部类与 Api

最新推荐文章于 2024-07-13 13:55:40 发布

weixin_47744616

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量140

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_47744616/article/details/122015290

版权

1.当方法中用到的参数是一个类的时候实际类是一个对象

package 类作为返回值参数;

public class Oper {
    public void useDog(Dog dog){
        dog.eat();
    }
}
//上面的是使用的 狗的方法  Dog 是一个类 但是下面 是掉方法所以传递的是 对象

package 类作为返回值参数;

public class Demotest {
    public static void main(String[] args) {
        Oper oper = new Oper();//操作类的对象
        Dog dog = new Dog();//创建狗的对象
        oper.useDog(dog);//需要狗的对象


    }
}
//把 对象 创建出来 放到 useDog()里面 

 public Dog createDog(){
        Dog dog = new Dog();
        //返回值是 类的时候  我们return 的是 对象
        return dog;
 }

2. 参数是类的时候需要的是对象返回值是类的时候返回的是对象

3.抽象类作为参数的时候抽象类是无法创建对象的我们可以用多态的创建对象方式创建 new的是子类对象

当返回值也是抽象类的的时候我们返回的也是抽象类的字类对象

总结只要是类的返回值或者参数我们返回或者需要的就是一个对象

4.当接收参数是接口类型的或者返回值是接口类型的都是需要的是

接口的实现类的对象

package 接口作为返回值;

public class Cat implements jump{
    @Override
    public void jump() {
        System.out.println("猫会跳");
    }
}

//实现类

package 接口作为返回值;

public class Oper {//操作类
    public void useEat(jump j){
        j.jump();
    }

    public jump getCat(){
        jump cat = new Cat();
        return cat;
    }
}
//操作类

package 接口作为返回值;

public interface jump {
    void jump();

}
//接口类

package 接口作为返回值;

public class Demotest {//测试类

    public static void main(String[] args) {
        Oper oper = new Oper();
//        jump j = new Cat();
        jump cat = oper.getCat();
        oper.useEat(cat);
    }
}
//测试类

5.内部类

内部类创建格式一个类里面嵌套一个内部类

package 内部类;

public class outer {//外部
    
    public class inner{
        
    }
}

内部类可以使用外部类的变量 (直接使用)

但是外部类不可以直接使用内部类的东西 外部类使用内部类的需要创建对象

6.成员内部类使用在外界使用

可以直接使用

方式是: 外部类.内部类对象名 = new 外部对象().new 内部对象();

但是注意 :上面这种是内部类是 public 的时候使用

  outer.inner inner = new outer().new inner();
        inner.use();

这样使用的:

!!!!注意但是正规写法我们是不允许上面这样创建内部类调用对象的我们会使用

外部类创建对象然后通过外部类的方法在外部类方法里面调用内部类创建内部类对象并调用内部类的方法

package 内部类;

public class outer {//外部
    private int age =10;
    private class inner{//内部类直接使用外部类 可以直接使用
        public void use(){
            System.out.println(age);
        }
    }
    //外部类使用 内部的需要创建 内部类的对象
    public void useMethods(){
        inner inner = new inner();
        inner.use();
    }
}
//上面是  内部类的创建结构


package 内部类;

public class Demotest {
    public static void main(String[] args) {
//        outer outer = new outer();
//        outer.useMethods();
//        outer.inner inner = new outer().new inner();
//        inner.use();
        outer outer = new outer();
        outer.useMethods();
    }
}


//上面是 测试类的内部结构

7.局部内部类

有成员变量局部变量

package 局部内部类;

public class Outer {

    private int age=10;

    public void inner(){
        class innnerin{
//            private int age;
            public void use(){
                System.out.println(age);
            }
        }
        innnerin innnerin = new innnerin();
        innnerin.use();
    }

}

局部内部类是放在方法里面的

8.匿名内部类

package 匿名内部类;

public class outer {
    //匿名内部类要求
    // 有一个接口  重写那个接口的方法
    /*
     *  new 接口(){
     *       重写接口的方法
     * }
     * */
    //匿名内部类也是局部的
    public void method() {

        new inter() {//因为这是个对象 所以可以直接new出来 然后.方法
            @Override
            public void show() {
                System.out.println("这是匿名内部类");
            }
        }.show();
        //或者我们利用多态的形式  new inter(){} 这就是 这个接口的实现类

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

        inter.show();

    }
}

9.匿名内部类中的应用

比如我们用操作实现类来传递接口里面需要传递的是一个接口类型的对象

接口.jump()跳高方法

传递的那个比如是猫可以跳高我们需要新建猫的类

而用匿名内部类我们就可以直接 (new Jump接口(){

重写接口的方法 (){

输出猫可以跳高了

}

})

就是简单的 new 出来直接写方法() 简单

10.Math 数学方法

math.数学方法

Math.abs(-99) 绝对值

Math.ceil(12.33)//返回一个大于或者等于这个数的整数

Math.floor(12.33)// 返回一个小于或者等于这个数的整数

Math.max(88,99)//返回最大值两个值的最大值

Math.min(88,99)//返回两个的最小值

Math.round(12.9333)//四舍五入的取整数

Math.random()//取值一个 [0,1) 的小数

11.System 系统类

System.exit()//系统关闭

System.currentTimeMillis()//系统时间距离1970年 1月1 号0.0分

12.Object.toString()方法

Ctrl+B代码找底层跟进参数被那个方法用到我们继续那个方法 Ctrl+B

toString 的底层就是返回一个 String 字符串一般建议我们重写 toString 方法

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

13.Object 的 equels 方法

@Override
    public boolean equals(Object o) {
        //把 student1 传入  this指的是 Student == o(Student1)
        if (this == o) return true;
        //若果他不是 继承于 Student下的 学生 返回  false
        if (!(o instanceof Student)) return false;
        //是的话  强制转换
        Student student = (Student) o;
        //比较 名字 跟 年龄
        return age == student.age && Objects.equals(name, student.name);
    }

重写 equals 方法

14.冒泡排序的原理

冒泡排序的原理

相邻的两个值两两比较

把最大的向后移动

15.Array 数组里面有方法

sort() 排序 ToString() 转换成字符串

16.integer

int 值的范围 min-value max-value 最大最小值

integer 可以转换为 String 或者将 String 转为 int

byte Byte short Short int Integr long Long float Float double Double

char Character boolean Boolean

int 的包装类

Integer i = Integer.Valueof("abc")

报错误这不是一个可以转换的数字

integer 包装类型的转换

integer 转 String 字符串

可以直接 ""+number 隐士转换

或者说用 String.valueof() 转换成

String 转 integr

String ====>转成 Integer

i.intvalue ===>中间转换

integer .parseInt()//直接转换

拆箱装箱自动的

包装类 ====>转非包装叫拆箱

非包装 ========> 包装叫装箱

在使用包装类型的时候最后先看看是不是 null 只要是引用类型首先判断不为null

日期

Date date1 = new Date(1000*60*60);
System.out.println(date1);

这个日期就是 1970年 0时0分0 秒一月一号

Integer在 JAVA 内用 32 位表示，因此 32 位能表示的最大值是 2147483647。另外1 年 365 天的总秒数是 31536000，

2147483647/31536000 = 68.1

也就是说32 位能表示的最长时间是 68 年，而实际上到 2038年 01 月 19 日 03 时 14 分 07
秒，便会到达最大时间，过了这个时间点，所有 32 位操作系统时间便会变为
10000000 00000000 00000000 00000000

也就是1901年 12月 13 日 20时 45 分 52 秒，这样便会出现时间回归的现象，很多软件便会运行异常了。

到这里，我想问题的答案已经出来了:

因为用32 位来表示时间的最大间隔是 68 年，而最早出现的 UNIX 操作系统考虑到计算
机产生的年代和应用的时限综合取了 1970 年 1 月 1 日作为 UNIX TIME 的纪元时间 ( 开始
时间 ) ，而 java 自然也遵循了这一约束。

至于时间回归的现象相信随着64 为操作系统的产生逐渐得到解决，因为用 64 位操作
系统可以表示到 292,277,026,596年 12月 4 日 15时 30 分 08 秒，相信我们的 N 代子孙，哪
怕地球毁灭那天都不用愁不够用了，因为这个时间已经是千亿年以后了。

package 日期类;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);

        Date date1 = new Date(1000*60*60);
        System.out.println(date1);

//        System.out.println(date.getTime());

        date.setTime(1641094842827L+(1000*60*30));
        System.out.println(date.getTime());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("YYYY年MM月DD日 HH:mm:ss");
        String format1 = simpleDateFormat.format(date);
        System.out.println(format1);
    }
}

这是日期

首先设置 simpleDateFormat 的返回日期的格式

然后把获取或者设置好的日期放进去最后输出的就是设置的日期

SimpleDateFormat 方法

无参构造默认的 () 就是默认的返回格式

有参构造就是我们需要设置 ()

YYYY 年 MM 月 DD 日 HH小时 mm分钟 ss 秒

方法对

日期工具类

创建日期工具类让无参构造私有化 () 外界不可以访问

组要日期对象跟日期格式

可以生成对应格式的日期

把日期创建好需要一个格式然后用 parse () 方法来解析成日期

日历类Calendar

日历类

获取日期对象 Calendar 获取日期对象 ()

获取日期 ===>Calendar .year 获取年

常用方法

calendar.get(日期,年份月份等)

calendar.add(日期,加减多少年月天)

calendar.set(年月日随自己设置)

package 日历类;

import java.util.Calendar;

public class 获取2月天 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();//创建日期对象
        instance.set(2019, 2, 1);//设置日期 为几几年 几月 几号
//        System.out.println(instance.get(instance.MONTH));
        instance.add(instance.DATE, -1);//再这个月份上 减少一天 就是 2月分的第一天 月份比实际获取的少一
        System.out.println(instance.get(instance.DATE));//输出当年的 2月份的天数
    }
}

异常

异常就是 java 代码运行的时候出现错误导致代码无法运行的原因

异常的超类是 throwable

异常会导致代码运行异常

异常有 error 错误 Expection 异常分运行时异常 ,非运行时异常

我们可以用 try catch 处理遗产

说白了处理异常就是让有异常的代码可以一直运行下去

异常报错的三种方法

异常 .toString 转换成字符串

异常.getMessage()//获取异常的信息

异常 .printStackTrace 异常的原因

编译时异常跟非编译时异常

编译时异常是告诉你我可能有问题并不代表一定会出问题异常就是出了异常后你咋解决

有好多办法

try Catch 与 throws 处理方法

try catch 才是真正的处理 throws 处理方式只是把异常向外抛出只是这里不好处理谁调用它谁处理把就像帮忙一样有时候可以帮你但有时帮不了你这本来是你的错你自己处理

throws 只是把异常抛出并不是处理了异常

自定义异常

所有的异常都是继承于 runExpection Expection 这两个异常

java 只是提供了我们平时常见的异常

并没有把所有的异常处理掉所以有的时候我们可以自己提供异常

可以自定义异常类让这类继承异常的父亲类就可以了

package 异常;

public class Myexpection extends Exception{
    public Myexpection() {
    }

    public Myexpection(String message) {
        super(message);
    }
}


package 异常;

public class Teacher {
    int source;
    public void CheckSource(int source) throws Myexpection {
        if(source <0 || source >100){
            throw new Myexpection("输入的分数要在0-100之间");
        }else{
            System.out.println("分数正常");
        }
    }
}



package 异常;

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
//        System.out.println("开始");
//        try {
//            int [] arr ={1,2,3,4};
//            System.out.println(arr[4]);
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//        System.out.println("结束");
        Scanner scanner = new Scanner(System.in);
        int source =scanner.nextInt();
        Teacher teacher = new Teacher();
        try {
            teacher.CheckSource(source);
        } catch (Myexpection myexpection) {
            myexpection.printStackTrace();
        }
    }
}

异常就是平时的我们的报错处理