JavaSE前半段基础总结

1.生成随机数

Random r=new Random();
int num=r.netInt(n)+1;//由[0,n)变成[1,n+1)即[1,n]

2.ArrayList常用方法

 		//向集合中添加元素
        list.add("lj");
        list.add("lbx");
        list.add("cyy");
        list.add("qd");
        list.add("hd");

        //从集合中获取元素：get,利用索引从0开始
        String s = list.get(2);
        System.out.println("2号索引位置的值："+s);

        //从集合中删除元素：remove，利用索引从0开始
        String s1 = list.remove(4);
        System.out.println("被删除的是："+s1);

        //获取集合的长度，即元素个数
        int size = list.size();
        System.out.println("集合长度为："+size);

3.字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中

对于基本类型来说，==是进行数值的比较
对于引用类型来说，==是进行地址值的比较

	    String str1="abc";
        String str2="abc";

        char[] charArray={'a','b','c'};
        String str3=new String(charArray);

        System.out.println(str1==str2);//true
        System.out.println(str1==str3);//false
        System.out.println(str2==str3);//false

4.字符串常用方法

        //获取字符串长度
        int length = "sdasdasfdsfjkwqe".length();
        System.out.println("字符串长度为："+length);

        //拼接字符串
        String str1="abc";
        String str2="def";
        String str3=str1.concat(str2);
        System.out.println(str3);

        //获取指定索引的单个字符
        String str4="dasdasfdfsas";
        char c = str4.charAt(5);
        System.out.println(c);

        //查找参数字符串在本来字符串当中第一次出现的索引位置，如果没有则返回-1
        String str5="HelloWorld";
        int i = str5.indexOf("llo");
        System.out.println(i);

	    //截取字符串
	    String str1="HelloWorld";
        String str2=str1.substring(5);
        System.out.println(str1);//HelloWorld
        System.out.println(str2);//World

        String str3=str1.substring(4,7);//[4,7)
        System.out.println(str3);//oWo

		//字符串替代
		String str1="How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str2);//H*w d* y*u d*?

		//字符串切割
		String str1="aaa,bbb,ccc";
        String[] strings = str1.split(",");

3.字符串转换

		//转换为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);//H
        System.out.println(chars.length);//5

        //转换为字节数组
        byte[] bytes = "abc".getBytes();
        for (byte aByte : bytes) {
            System.out.println(aByte);//97 98 99
        }

4.Arrays

		int[] array={10,20,50};
        //将int数组按照默认格式变成字符串
        String intstr = Arrays.toString(array);
        System.out.println(intstr);//[10,20,50]

		//排序
		int[] array1={5,3,7,8,10,11};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[3, 5, 7, 8, 10, 11]

5.继承
在父子继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：
1）.直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
2）.简介通过成员方法访问成员变量：
该方法属谁，就优先用谁，没有则向上找。

6.如何才能知道父类引用的对象，本来是什么子类？

		Animal animal=new Cat();//本来是一只猫
        animal.eat();

        //如果希望调用子类特有方法，需要向下转型
        //判断父类引用animal本来是不是Dog
        if (animal instanceof Dog){
            Dog dog=(Dog) animal;
            dog.methodDog();
        }
        //判断父类引用animal本来是不是Cat
        if (animal instanceof Cat){
            Cat cat=(Cat) animal;
            cat.methodCat();
        }

7.内部类
如果一个事物内部包含另一个事务，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系，汽车和发动机的关系

分类：
1.成员内部类
2.局部内部类（包含匿名内部类）
注意：内用外可以随意访问，外用内需要内部类对象

使用成员内部类的两种方式：
1.间接方式：在外部类的方法当中使用内部类，main中调用外部类方法
2.直接方式：
外部类名称.内部类名称 对象名=new 外部类名称（）.new 内部类名称（）;

public class Body {//外部类
    public class Heart{//成员内部类
        public void beat(){
            System.out.println("心脏跳动");
            System.out.println("我叫"+name);//正确写法
        }
    }
     public void method(){
        System.out.println("外部类的方法");
        Heart heart=new Heart();
        heart.beat();
    }
}

main方法

    public static void main(String[] args) {
        Body body=new Body();//外部类对象
        //在外部类的方法当中使用内部类
        body.method();

        Body.Heart heart=new Body().new Heart();//内部类对象
        heart.beat();
    }

8.finally关键字
final关键字代表最终、不可改变的。
常见用法：
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.可以用来修饰一个局部变量
4.可以用来修饰一个成员变量

a.当final关键字修饰一个类时：
当前这个类不能有任何子类（太监类）

b.当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写
注意事项：
对于类、方法来说，abstract和final关键字不能同时使用，因为矛盾

c.final关键字修饰局部变量，则这个变量就不能进行更改
注意：
对于基本类型来说，不可变说的是变量当中的数值不可变
对于引用类型来说，不可变说的是当中的地址值不可改变

d.如果成员变量使用final关键字修饰，那么这个变量照样是不可变。
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么直接赋值，要么通过构造方法赋值,二者选其一。
3.必须保证类中所有重载的构造方法，最终都会对final的成员变量进行赋值。

9.修饰符
Java中的四种权限修饰符：

	public	protected	(default)	private
同一个类	yes	yes	yes	yes
同一个包	yes	yes	yes	no
不同包子类	yes	yes	no	no
不同包非子类	yes	no	no	no

10.Date

		Date date1=new Date();
        long time = date1.getTime();//与下方sout功能一样
        System.out.println(time);
        System.out.println(System.currentTimeMillis());//获取当前系统从1970年1月1日 00:00:00（英国，中国加8个小时）到现在经历的毫秒

        Date date=new Date();//当前日期
        System.out.println(date);

        date=new Date(0L);//把毫秒转成对应日期
        System.out.println(date);

11.DateFormat

		Date date=new Date();

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//日期格式化为字符串
        String format = sdf.format(date);
        System.out.println(format);

        Date parse = sdf.parse("2020-11-18 19:14:42");//字符串解析为日期
        System.out.println(parse);

12.StringBuilder
StringBuilder:字符串缓冲区，提高字符串效率
String和StringBuilder可以相互转换：
String–>StringBuilder
可以使用StringBuilder构造方法，例：StringBuilder bu2 = new StringBuilder(“abc”);
StringBuilder–>String
可以使用StringBuilder的toString方法

		//空参构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);//bu1:
        //添加数据
        StringBuilder bu3 = bu1.append("abc");
        System.out.println("bu3:"+bu3);//bu3:abc
        System.out.println(bu1==bu3);//true

        //使用append无需返回值
        bu1.append("abc");
        bu1.append(2);
        bu1.append(true);
        bu1.append(8.8);
        bu1.append("中");
        System.out.println("bu1:"+bu1);//bu1:abcabc2true8.8中

        //链式编程:方法返回值是一个对象，可以继续调用方法
        bu1.append("qwe").append(1).append("芜湖").append(true);
        System.out.println("bu1:"+bu1);//bu1:abcabc2true8.8中qwe1芜湖true

        //带字符串构造方法，String-->StringBuilder
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);//bu2:abc

        //StringBuilder-->String
        String str = bu2.toString();
        System.out.println("str:"+str);//str:abc

13.装箱与拆箱

		//构造方法，装箱
        Integer int1 = new Integer(1);
        System.out.println(int1);

        Integer int2 = new Integer("1");
        System.out.println(int2);

        //静态方法
        Integer int3 = Integer.valueOf(1);
        System.out.println(int3);

        Integer int4 = Integer.valueOf("1");
        System.out.println(int4);

        //拆箱
        int i = int1.intValue();
        System.out.println(i);

自动装箱与自动拆箱：基本类型和包装类之间可以自动的相互转换

		//自动装箱:直接把int类型的整数赋值包装类
        Integer integer=1;//相当于Integer int1 = new Integer(1);
        //自动拆箱：integer是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算
        integer=integer+1;//相当于integer.intValue()+1

14.基本类型与字符串类型之间的相互转换
基本类型–>字符串
1.基本类型值+"" 最简单的方法（工作中常用）
2.包装类的静态方法toString(参数)，不是Object类的toString()方法,重载
3.String类的静态方法valueOf(参数)
字符串–>基本类型
1.使用包装类静态方法parseXXX(“字符串”);

        //基本类型-->字符串
        int i1=100;
        String s1=i1+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);

        String s3 = String.valueOf(100);
        System.out.println(s3+200);

        //字符串-->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);//90