访问权限修饰符

/*
    1.Java有四种访问权限修饰符,从宽到窄
        public:公有的,可以被本项目下所有包的其他类访问
        protected:受保护的,可以被同包下的其他类访问,包外只能被子类访问
         (什么都不写):只能被同一个包的类访问
         private :私有的,只能被本类成员访问
    2.作用
        用于控制一个类,类成员,是否可以被其他类访问

    3.类可以使用的访问权限修饰符
        public:表示这个类可以被本项目下所有包的其他类访问
        什么都不写:默认的,表示只可以被本包的其他类访问
    4.类成员可以使用的访问权限修饰符
        public:表示这个类可以被本项目下所有包的其他类访问
        protected:表示可以被本包的所有类访问,包外只能被子类访问
        什么都不写:默认的,表示只可以被本包的其他类访问
        private:私有,只能被本类访问
*/
    //自定义类
    public class Student(){
        public int a = 10;
        protected int b = 20;
        int c = 30;
        private int d = 40;
}
    //测试类
    public class Demo(){
        public static void main (String[] args){
            Student stu = new Student();
            System.out.println(stu.a);//10
            System.out.println(stu.b);//20
            System.out.println(stu.c);//30
            //System.out.println(stu.d)无法访问该成员,因为是被private修饰的,只能被本类访问
    }
}
publicprotected默认的private
同一个类
同一个包的子类与其他类
不同包的子类
不同包的其他类

代码块

/*
    代码块:有三种
        1).构造代码块:定义在类体中,用一对{}括起来的代码块
        每次创建对象会自动执行一次,而且会在构造方法前执行
        作用:多个"构造方法"都要做的事情可以放在"构造代码块"里
        2).静态代码块:定义在类提中,用static{}定义的代码块
        每一次使用这个类的时候会被自动执行一次,且本程序执行过程中,只执行一次
        作用:初始化"静态成员"属性
        3).局部代码块:定义在方法内部的,用一堆{}括起来的代码块
        当方法执行到这一行的时候会被执行,局部代码块不影响执行顺序
        作用:限制一些大对象的生命周期
*/
    自定义类Student:
        public class Student(){
            public int[] a = new int[100];
            //构造代码块
            {System.out.println("我是构造代码块");}
            //静态代码块
            static{
            System.out.println("我是静态代码块");
            for(int i = 0;i<a.length;i++){
                a[i]=i+1;
        }
    }
}
    //定义测试类:Demo
        public class Demo{
            public static voud main(String[] args){
            Student stu1 = new Student();
            //局部代码块
            {
            Student stu2 = new Student();
            System.out.println("我是局部代码块");
        }
            //System.out.println(stu2);无法获取对象地址,因为是在局部代码块里创建的对象,被限制了生命周期
    }
}
    执行结果-->
            我是静态代码块
            我是构造代码块
            我是构造代码块
            我是局部代码块

Object 类

Object类概述
    1).java.lang.Object(类)所有类都默认继承自这个类,所有数组、对象,包括我们自定义的类,实现这个类的方法
        public class Student(){//隐式继承自Object类
}
    2).任何引用类型的都继承了Object的多数方法,其中两个重要的方法
        1.)toString();
        2.)equals();
        这就说明了所有的类和数组都有这两个方法
自定义类Student
    public class Student(){
        String name = "qianyiyi";
            int age = "20";
    @Override
        public String toString(){
        System.out.println(a);
    }
 public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

定义测试类Demo
    public class Demo{
    //toString方法
    Student stu1 = new Student();
        System.out.println(stu1)//隐式调用对象的toString();方法

//equals方法
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("张三",18);
        System.out.println("stu1==stu2结果"+(stu1==stu2));
        System.out.println("stu1.equals(stu2)结果"+stu1.equals(stu2));
}

Date类

        /*
            1).Java.util.Date(类):他表示一个时间,精度:毫秒
            2).创建对象
                1).new Date():无参构造,表示当前系统时间
                2).new Date(long m ):使用毫秒值构造一个Date对象。他内部表示:从1970年1月1日零时开始到参数的一个毫秒值
            3).成员方法
                public long getTime():获取Date对象从1970年1月1日零时开始,到
Date对象时间之间的一个总毫秒值
                public void setTime():设置此Date对象的毫秒值,此Date对象表现的时间将会被改变
        */
    定义测试类:Demo
    public classs Demo(){
        public static void main(String args[]){
            Date date = new Date()
            System.out.println(date);//以英文的方式表示当前系统时间
            long time = date.getTime();//获取当前系统时间的毫秒值
            date.setTime(1000);//设置当前date对象的毫秒值
    }
}

DateFormat(日期格式类)

1).java.text.DateFormat(抽象类):是一个对"日期"进行格式化显示的类,因为是一个抽象类,不能创建对象,所以我们可以用它的子类:Java.text.SimpleDateFormat

2).java.text.SimpleDateFormat(类):

  • 构造方法

    • SimpleDateFormat(String parent):使用一个字符串格式构造一个SimpleDateFormat对象。

      • y:年
      • M:月
      • d:日
      • H:小时(0-23)
      • m:分钟
      • s:秒
  • 成员方法

    • String Format(Date date):将Date对象转换为String对象
    • Date Parse(String s):将String对象转换为Date对象
  • 实例代码

    //自定义测试类Demo
        public class Demo(){
            public static void main(String args[]) throws ParseException{
                //1.创建一个SimpleDateFormat对象
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
                //2.创建一个Date对象
                Date date = new Date();
                //3.对date对象进行格式化
                String str = sdf.format(date);
                System.out.println(str);//2021年7月23日11:09:19
    
    
    
    
                //将字符串对象(String)转换为日期(Date)对象
                //1.定义一个日期的格式化对象
                SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
                //2.使用字符串定义一个时间
                String sd = "2021年07月23日11时09分19秒";
                //3.将字符串对象转换为Date对象
                Date d = sdf2.parse(sd);//这里有异常,我们把他抛出去Idea快捷键Alt+Enter、Enter
                System.out.println(d);//输出结果:"Fri Jul 23 11:09:19 CST 2021"
        }
    }

Calendar(日历类)

/*1).java.util.Calendar(抽象类):一个"日历"类,可以对日期进行运算
    因为是抽象类,不能创建对象
    1).可以使用子类:GregorianCalendar.
    2).或者通过Calendar的静态方法:getInstance,可以获取一个实例化对象
2).常用的成员方法:
    1).public int get(int field):获取某个字段的值。
    2).public void set(int field,int value):为field字段设置value值。可以设置:年、月、日、小时、分、秒...等字段的值
    3).public void add(int field,int value):为field字段,增加value值
3).示例代码*/
public class Demo3 {
    public static void main(String[] args) {
        //1.获取一个GregorianCalendar对象
        Calendar c1 = Calendar.getInstance();

        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH) + 1;
        int day = c1.get(Calendar.DAY_OF_MONTH);

        int hour = c1.get(Calendar.HOUR_OF_DAY);
        int minute = c1.get(Calendar.MINUTE);
        int second = c1.get(Calendar.SECOND);

        int week = c1.get(Calendar.DAY_OF_WEEK);//取出的是:1-7的值,对应的是:星期日、星期一、....、星期六

        System.out.println(year + "年" + month + "月" + day + "日 " + hour + ":" + minute + ":" + second);
        System.out.println(getWeek(week));

        //2.set(int field,int value)
        //需求:查看:2001-04-18那天是星期几
        //1.获取当前系统时间的Calendar
        Calendar c2 = Calendar.getInstance();
        //2.将年月日设置为"指定日期"
        c2.set(Calendar.YEAR, 2001);
        c2.set(Calendar.MONTH, 4 - 1);
        c2.set(Calendar.DAY_OF_MONTH, 18);
        //3.获取星期
        int w = c2.get(Calendar.DAY_OF_WEEK);
        //4.查表
        System.out.println("2001-04-18日那天是:" + getWeek(w));

        //3.add(int field,int value)
        //需求:计算100天后,是哪年哪月哪日,星期几
        //1.获取当前系统时间的Calendar
        Calendar c3 = Calendar.getInstance();
        //2.将"日期" + 100
        c3.add(Calendar.DAY_OF_MONTH, -100);
        //3.获取新的年、月、日
        int y = c3.get(Calendar.YEAR);
        int m = c3.get(Calendar.MONTH) + 1;
        int d = c3.get(Calendar.DAY_OF_MONTH);
        System.out.println("100天后:" + y + " 年 " + m + " 月 " + d + " 日 ");
        w = c3.get(Calendar.DAY_OF_WEEK);
        System.out.println("那天是:" + getWeek(w));
    }

    //定义一个方法,可以根据一个1-7的星期值,返回:中文表示
    public static String getWeek(int week) {//week值:1---7
        //查表法:
        //1.定义一个表(String[])
        String[] weeks = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};

        //2.查表
        return weeks[week - 1];

    }
}
最后修改:2021 年 07 月 26 日 04 : 07 PM
如果觉得我的文章对你有用,请随意赞赏