峰扬

package date;

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

public class Demo {
    public static void main(String[] args) {
        //获取当前时间的时间戳（默认毫秒）
        Date d1 = new Date(System.currentTimeMillis());
        System.out.println(d1);
        System.out.println(d1.getTime());


        /**
         * 时间格式化处理
         */
        //将时间戳转换成日期时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//用指定的格式 来格式化时间和日期
        Date d = new Date();//获取当前是时间戳
        System.out.println(sdf.format(d));//将时间戳转换为日期格式
        String ss = sdf.format(d);
        System.out.println(ss);//2020-12-15 16:09:36

        //将时间转换成时间戳
        String dt = "2019-08-09 11:11:11";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            long ts = sdf1.parse(dt).getTime() / 1000;//不知道为什么 parse 这个方法必须放在try结构中才不会报错 我的jdk是15.1
            System.out.println(ts);
            //再试着转回去
            System.out.println(sdf.format(ts * 1000));//2019-08-09 11:11:11

        } catch (ParseException e) {
            e.printStackTrace();
        }




    }
}

1. 时间戳
2. 数组排序
3. string 和 int 互转

package inter;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        
        /**
         * Arrays 类 处理数组
         */
        //数组排序
        int[] arr = {12,58,36,54,11,45,74,61};
        System.out.println(Arrays.toString(arr));//[12, 58, 36, 54, 11, 45, 74, 61]
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));//[11, 12, 36, 45, 54, 58, 61, 74]


        /**
         * System 类 系统信息
         */
        //获取当前机器的毫秒时间戳
        long time = System.currentTimeMillis();
        System.out.println(time);//1608001816760
        //将毫秒时间戳转换为秒时间戳
        System.out.println(time / 1000);//1608001816

        //退出JVM虚拟机 status为负数表示异常退出
        //System.exit(-1);//进程已结束,退出代码-1

        /**
         * 基本数据类型的包装类
         * 基本数据类型       包装类
         * byte             Byte
         * shot             Short
         * int              Integer
         * long             Long
         * float            Float
         * double           Double
         * char             Characetr
         * boolean          Boolean
         */
        //例如：判断一个int的数据是否在int数据范围
        long i = 1545154586454L;
        System.out.println(i);//1545154586454
        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648

        System.out.println((i > Integer.MAX_VALUE && i < Integer.MIN_VALUE) ? "该数据在int范围内" : "该数据不在int范围内");//该数据不在int范围内

        //将 string 转换为 integer 对象
        String s = "100";
        //System.out.println(Integer.valueOf("你好"));//报错 注意 该字符串必须是数字类型的字符串
        //方式一
        Integer s1 = Integer.valueOf(s);//先转换成 Integer 对象
        System.out.println(s1.intValue());//123456
        //方式二
        System.out.println(Integer.parseInt(s));//100

        //将 int 转换为 string 类型
        int number = 100;
        //方式一
        String s2 = "" + number;
        System.out.println(s2);//100
        //方式二
        System.out.println(String.valueOf(number));//100




    }
}

package str;

import java.util.Arrays;

/**
 * String
 * 字符串处理
 */
public class Str {
    public static void main(String[] args) {
        //字符串拆分
        String s = "91 27 46 38 50";
        String[] a = s.split(" ");//根据字符串中的拆分规律 " " 来拆分，并且拆分完成后的数据是一个数组（这是是将string拆分，因此返回的数据是string数组）
        System.out.println(a);//[Ljava.lang.String;@16b98e56 数组地址值
        System.out.println(Arrays.toString(a));//[91, 27, 46, 38, 50] 使用Arrays查看数组

        Integer ii = 100;
        System.out.println(ii.intValue() + 200);
    }
}

Demo

package obj;

/**
 * 多态中的转型谷
 */
public class Dome {
    public static void main(String[] args) {
        /**
         * 实例化基类
         */
        //多态 - 向上转型
        Animal c = new Cat();
        System.out.println(c.name); // 动物
        //System.out.println(c.age); //报错，因为 Animal类中没有age属性
        c.skill(); //抓老鼠



        System.out.println("-------------------");

        //子类正常调用方式
        /*Cat c1 = new Cat();
        System.out.println(c1.name);//猫
        System.out.println(c1.age);//5 不报错，因为 Cat 类中有age属性
        c1.skill();//抓老鼠*/


        /**
         * 以上方法虽然能够调用到子类中的属性
         * 但是 是实例化的一个新的对象
         *
         * 通过转型（向下转型将实例化的 Animal对象的实例转换成子类 ）
         * Cat a = (Cat)Cat();
         */
        //向下转型
        Cat a = (Cat) c;//将 Animal对象的实例转换成子类
        System.out.println(a.age);//5




    }
}

基类

package obj;

public class Animal {
    String name = "动物";

    public void skill()
    {
        System.out.println("警惕");
    }
}

子类

package obj;

public class Cat extends Animal{
    String name = "猫";
    byte age = 5;

    public void skill() {
        System.out.println("抓老鼠");
    }
}

Demo：

package obj;

/**
 * 多态
 */
public class Dome {
    public static void main(String[] args) {
        /**
         * 多态的实现方式：
         * 1、类型定义的是基类   Animal
         * 2、实例化的是派生类   Cat
         * 通过基类调用其中的方法和属性
         *
         * NOTE:
         * 通过基类调用属性，返回的是基类中的属性
         * 通过基类调用方法，返回的是子类中重写的方法
         */
        //多态
        Animal c = new Cat();
        System.out.println(c.name); // 动物
        //System.out.println(c.age); //报错，因为 Animal类中没有age属性
        c.skill(); //抓老鼠



        System.out.println("-------------------");

        //正常调用方式
        Cat c1 = new Cat();
        System.out.println(c1.name);//猫
        System.out.println(c1.age);//5 不报错，因为 Cat 类中有age属性
        c1.skill();//抓老鼠


    }
}

基类：

package obj;

public class Animal {
    String name = "动物";

    public void skill()
    {
        System.out.println("警惕");
    }
}

派生类：

package obj;

public class Cat extends Animal{
    String name = "猫";
    byte age = 5;

    public void skill() {
        System.out.println("抓老鼠");
    }
}

package gather;


import java.util.ArrayList;

/**
 * 集合之ArrayList
 * 集合的特点：
 * 一种存储空间可变的存储模型，存储的数据容量可以发生改变
 * ArrayList<E>
 *     E:表示集合中存储的元素类型 如创建Study类的集合，则为Study
 */
public class ArrList {
    public static void main(String[] arge) {
        ArrayList array = new ArrayList<String>();
        System.out.println(array);//[] 该集合还没有元素

        //添加元素
        //ArrayList.add()
        array.add("Hello");
        array.add(" ");
        array.add("Java");
        System.out.println(array);//[Hello,  , Java]

        //指定位置添加元素
        array.add(1,"location");
        System.out.println(array);//[Hello, location,  , Java] 原索引的元素被挤到后一位去了（后面所有索引+1）

        //指定不存在的索引添加 - 报错（集合越界）
        //array.add(5,"what"); //IndexOutOfBoundsException 和数组一样，产生索引越界 这里是集合越界

        //修改指定元素
        array.set(1,"王炸");
        System.out.println(array);//[Hello, 王炸,  , Java]

        //查看指定元素
        System.out.println(array.get(0));//Hello

        //查看集合中的个数
        System.out.println(array.size());//4

        //删除元素
        array.remove(2);
        System.out.println(array);//[Hello, 王炸, Java]

     

    }
}

package array;

/**
 * 数组必须初始化后才能使用
 * 初始化分为：
 * 1、动态初始化
 *     初始化时只指定数组长度，由系统为数组分配初始值
 * 2、静态初始化
 *
 * NOTE:
 * 定义在局部中的变量为：栈内存
 * 存储new出来的内容为：堆内存
 * 每个new出来的数据都会有一个地址值，在数据使用完后会在垃圾回收器空闲时回收（非主动销毁）
 */
public class ArrarInit {
    public static void main(String[] arge)
    {
        //动态初始化
        int[] arr = new int[3];
        //输出数组第一个元素
        System.out.println(arr);//I@16b98e56 打印数组，返回的是数组在内存中的内存地址


        //静态初始化 定义了3个元素
         int[] arrb = {1,2,3};
         System.out.println(arrb[0]);
         System.out.println(arrb);//I@7ef20235



    }
}

IntelliJ IDEA官网现在有免费的社区版，可以直接下载
选择文件->新建->项目

选择Java模块->项目SDK选择Java安装目录

新建项目->输入项目名称->选择项目保存位置

在创建好的项目中点击自动生成的src目录->新建->包

输入包名

点击包->新建->Java类

输入类的文件名

在新建类文件中编写测试代码

点击右键选择运行，省却终端编译操作步骤

运行结果在底部区域查看

变量注意：

1. 变量名不能重复
2. 变量必须初始化（未赋值不能使用）
3. 整数类型变量默认数据类型是int，赋值时为防止类型不兼容需要在数值后面加上L（表示转换为long类型）
4. 浮点类型变量，默认数据类型是double，赋值时为防止类型不兼容需要在数值后面加上F（表示转换为float类型）

数据类型转换：

1. 自动转换

public class demo1 {
    public static void main(String[] arge){
        char a = 'a';
        int b = a;

        System.out.println(b);
    }
}

2. 强制转换类型：

public class demo1 {
    public static void main(String[] arge){
        //强制类型转换
        float a = 88.88F;
        int z = (int) a;
        System.out.println(z);//88
    }
}

NOTE：

1. 自动转换类型只能由 低数值范围 的数据转换到 高数值范围 的数据
2. 强制类型转换可以由高数值范围转换为低数值范围的数据，但是必须指定转换的数据类型

常量：

1. 字符串常量：用双引号括起来的内容
2. 整数常量：不带小数点的整数，包括正数和负数
3. 小数常量：带小数点的数字
4. 字符常量：用单引号括起来的内容
5. 布尔常量：true、false
6. 空常量： null

基本数据类型：

1. 数值型：

• 整数（byte,short,int,long）
• 浮点数(float,double)
• 字符(char)

2. 非数值型：

• 布尔(boolean)

  引用数据类型：

• 类（class）
• 接口(interface)
• 数组（[]）

数值型的取值范围：