one-18 内部类 Date时间类

最新推荐文章于 2024-10-06 20:16:20 发布

百川探

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量445

点赞数

分类专栏： one 文章标签： java 语音识别

本文链接：https://blog.csdn.net/weixin_58828748/article/details/120461869

版权

one 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.内部类

1.普通内部类

package cn.tedu.innerclass;
/*本类用作内部类的入门案例*/
public class TestInner1 {
    public static void main(String[] args) {
        //3.1创建内部类的对象，使用内部类的资源
        /*外部类名.内部类名 对象名=外部类对象.内部类对象*/
        Outer.Inner oi = new Outer().new Inner();
        //3.2通过创建好的内部类对象，使用内部类的资源
        oi.delete();
        System.out.println(oi.sum);
        //3.3外部想要使用外部类的资源，需要通过外部类的对象
        new Outer().play();
    }
}

//1.创建外部类
class Outer{
    //1.1 创建外部类的成员变量
    String name;
    private int age;
    //1.2创建外部类的成员方法
    public void play(){
        System.out.println("Outer...play()");
        //5.测试外部类能否使用内部类的资源
        //delete();--不能直接调用内部类的方法
        //System.out.println(sum);--不能直接查看内部类的属性
        /*外部类如果想要使用内部类的资源，必须先创建内部类的对象
         * 通过内部类对象调用内部类的功能*/
        Inner in = new Inner();//直接创建内部类对象，无需指定外部类，已经在外部类里了
        System.out.println(in.sum);//通过内部类对象查看内部类的属性
        in.delete();//通过内部类对象调用内部类的方法
    }
    //2.创建内部类--被看作是外部类的一个特殊成员
    class Inner{
        //2.1 定义内部类的成员变量
        int sum = 10;
        //2.2定义内部类的成员方法
        public void delete(){
            System.out.println("Inner...delete()");
            //4.测试内部类能否使用外部类的资源
            play();//可以调用外部类的方法
            System.out.println(name);//可以查看外部类的普通属性
            System.out.println(age);//可以查看外部类的私有属性
        }
    }
}

2.被private修饰的内部类

package cn.tedu.innerclass;
/*本类用于测试成员内部类被private修饰*/
public class TestInner2 {
    public static void main(String[] args) {
        //4.创建内部类对象使用内部类的资源
        //Outer2.Inner2 oi = new Outer2().new Inner2();
        //oi.eat();
        /*2.如果成员内部类被private修饰，外部无法直接访问或创建内部类的对象*/
        //7.间接访问，虽然创建不了私有内部类的对象，但是可以创建外部类的对象
        new Outer2().getInner2Eat();
    }
}
//1.创建外部类
class Outer2{
    //6.提供一个公共的方法，在方法内部创建内部类Inner2的对象，调用内部类的功能
    public void getInner2Eat(){
        Inner2 in = new Inner2();//可以在外部类里创建私有成员内部类的对象
        in.eat();//通过创建好的内部类对象调用内部类的功能
    }
    /*1.成员内部类的位置：类里方法外*/
    //2.创建成员内部类Inner2
    //5.用private修饰成员内部类
    private class Inner2{
        //3.创建成员内部类的普通方法
        public void eat(){
            System.out.println("Inner2...eat()");
        }
    }
}

3.被static修饰的内部类

package cn.tedu.innerclass;
/*本类用于测试成员内部类被static修饰*/
public class TestInner3 {
    public static void main(String[] args) {
        //4.1创建内部类对象访问内部类资源 方式一
        //Outer3.Inner3 oi = new Outer3().new Inner3();
        //oi.show();
        //4.2创建内部类匿名对象访问内部类资源 方式二
        //new Outer3().new Inner3().show();

        /*现象：当内部类被static修饰以后，new Outer3()报错，注释掉上面的代码*/
        //6.1由于内部类是静态的，所以可以通过外部类类名直接找到，不用额外创建外部类对象
        Outer3.Inner3 oi = new Outer3.Inner3();
        oi.show();
        //6.2方式二：创建匿名静态成员内部类对象
        new Outer3.Inner3().show();

        //8.1调用内部类的静态方法，方式一：不推荐
        new Outer3.Inner3().show2();
        //8.2调用内部类的静态方法，方式二：推荐
        /*没有创建任何一个对象，直接都是通过类名找到的静态资源
         * 象这样连着点的方式，称作：链式加载*/
        Outer3.Inner3.show2();
    }
}

//1.创建外部类
class Outer3{
    //2.创建成员内部类
    //5.用static修饰成员内部类
    static class Inner3{
        //3.定义成员内部类的普通方法
        public void show(){
            System.out.println("Inner3...show()");
        }
        //7.创建一个静态成员内部类中的静态方法
        static public void show2(){
            System.out.println("Inner3...show2()");
        }
    }
}

4.局部内部类

package cn.tedu.innerclass;
/*本类用于测试局部内部类*/
public class TestInner4 {
    public static void main(String[] args) {
        //5.创建外部类的对象，调用外部类的show()
        new Outer4().show();
        //new Outer4().new Inner4();//会报错
        /*如何使用局部内部类的资源呢？
         * 创建外部类对象调用外部方法或者直接在main()创建局部内部类对象都是不可行的
         * 需要在外部类中创建内部类的对象，并且调用内部类的方法，才会触发内部类的功能*/
    }
}
//1.创建外部类
class Outer4{
    //2.创建外部类的成员方法
    public void show(){
        System.out.println("Outer4...show()");
        /*局部内部类的位置：在方法里*/
        //3.创建局部内部类
        class Inner4{
            //4.创建局部内部类的资源
            String name;
            int age;
            public void eat(){
                System.out.println("Inner4...eat()");
            }
        }

        /*如何使用局部内部类的资源？*/
        //6.在show()里创建内部类对象，调用内部类的功能
        Inner4 in = new Inner4();
        in.eat();
        System.out.println(in.age);
        System.out.println(in.name);
    }

}

5.匿名内部类

package cn.tedu.innerclass;
/*本类用于测试匿名内部类
 * 匿名内部类没有名字，通常与匿名对象结合在一起使用*/
public class TestInner5 {
    public static void main(String[] args) {
        //传统方式：创建接口的实现类+实现类实现接口中的抽象方法+创建实现类对象+通过对象调用方法
        //3.创建接口一对应的匿名对象与匿名内部类，并调用实现了的方法save()
        new Inter1(){
            @Override
            public void save() {
                System.out.println("save()...");
            }
            @Override
            public void get() { }
        }.save();

        //5.创建抽象类对应的匿名对象与匿名内部类
        new Inter2(){
            @Override
            public void drink() {
                System.out.println("一人饮酒醉");
            }
        }.drink();
        //7.调用普通类的功能怎么调用？创建匿名对象直接调用
        new Inter3().powerUp();
        new Inter3().powerUp();//new了2次，所以是两个匿名对象
        /*如果想要多次使用实现后的功能，还是要创建普通的对象
         * 匿名对象只能使用一次，一次只能调用一个功能
         * 匿名内部类其实就充当了实现类的角色，去实现未实现的抽象方法，只是没有名字而已*/
        Inter3 in = new Inter3();
        in.study();
    }
}

//1.创建接口
interface Inter1{
    //2.定义接口中的抽象方法
    void save();
    void get();
}
//4.创建抽象类
abstract class Inter2{
    public void play(){
        System.out.println("Inter2...play()");
    }
    abstract public void drink();
}
//6.创建普通类
class Inter3{
    public void study(){
        System.out.println("什么都阻挡不了我想学习赚钱的决心");
    }
    public void powerUp(){
        System.out.println("我们会越来越强的！");
    }
}

2.Date时间类

/*本类用于Date的入门案例*/
public class TestDate1 {
    public static void main(String[] args) {
        //1.利用无参构造创建日期对象，注意导包：import java.util.Date;
        Date d1 = new Date();
        System.out.println(d1);//Fri Sep 24 17:04:16 CST 2021

        //2.利用含参构造创建日期对象
        long t = 1000*60*60;//1000ms*60*60->1min*60->1h
        //从标准基础时间【1970-1-1 00：00】开始往后数tms
        Date d2 = new Date(t);
        System.out.println(d2);//Thu Jan 01 09:00:00 CST 1970
        //本来变成了1点，但是我们中国的标准时间需要加8h,所以变成了9点
    }
}

/*本类用于练习Date的常用方法*/
public class TestDate2 {
    public static void main(String[] args) {
        //1.创建Date对象
        Date d1 = new Date();
        //2.获取从标准基准时间到现在的毫秒值
        System.out.println(d1.getTime());//1632474787688
        System.out.println(d1.getTime()*1.0/1000/60/60/24/365);//约等于51年，1970+51=2021

        System.out.println(d1);//Fri Sep 24 17:16:06 CST 2021
        long t = 1000*60*60;//定义一个小时
        d1.setTime(t);//Thu Jan 01 09:00:00 CST 1970,从标准基准时间数t模ms,注意东八区需要加8h
        System.out.println(d1);

    }
}

/*本类用于练习日期转换工具类SimpleDateFormat*/
public class TestSDF {
    public static void main(String[] args) throws ParseException {
        /*方向：Date -> String*/
        //1.创建日期对象
        Date d1 = new Date();
        //2.创建日期转换工具类的对象
        SimpleDateFormat sdf = new SimpleDateFormat();
        //3.利用日期转换类，将日期转换为字符串
        String s = sdf.format(d1);
        System.out.println(s);//默认效果：21-9-24 下午5:22
        //4.创建日期转换工具类的对象2
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
        //5.利用刚刚指定的规则，使用日期转换工具类对象转换时间
        String s2 = sdf2.format(d1);
        System.out.println(s2);//自定义效果：2021/09/24 05:26:40

        /*方向：String -> Date*/
        //1.定义一个时间字符串
        String s3 = "2021/09/24 05:26:40";
        //2.创建日期转换工具类对象,注意！！！一定要指定转换的规则，否则报错！
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
        //3.利用日期转换工具类对象进行日期转换,注意抛出异常
        Date d3 = sdf3.parse(s3);
        //4.打印转换好的日期
        System.out.println(d3);
    }
}