访问权限修饰符

/*
    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修饰的,只能被本类访问
    }
}

代码块

/*
    代码块:有三种
        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];

    }
}