JavaSE总结

一、方法重载

注意：static方法不能调用非静态方法，但非静态方法往往可以调用static方法。因为static会先实例化，静态方法和静态属性都是。 

方法名称相同，参数类型和数目不同，返回值类型可以相同也可以不同。

    public static void main(String[] args) {
        double m = max(10,20);
        System.out.println("最大值是"+m);
    }

    public static double max(double a,double b){
        double m;
        if (a==b){
            return 0;
        } else if (a>b) {
            m = a;
        }else {
            m = b;
        }
        return m;
    }
    public static int max(int a,int b){
        int m;
        if (a==b){
            return 0;
        } else if (a>b) {
            m = a;
        }else {
            m = b;
        }
        return m;
    }

    public static int max(int a,int b,int c){
        int m;
        if (a==b){
            return 0;
        } else if (a>b) {
            m = a;
        }else {
            m = b;
        }
        return m;
    }

二、递归

两个部分：

（1）递归头：什么时候不调用自身，没有将陷入死循环。

（2）递归体：什么时候调用自身。

三、数组

1、使用new操作来创建数组：

//直接定义
int[] arrays0;
//用new来创建数组
int[] arrays1 = new int[10];
String[] arrays2 = new String[100];
//二维数组
int[][] arrays4 = new int[10][10];
//对象数组
Demo01[] arrays3 = new Demo01[10];

2、冒泡排序

        //冒泡排序
        for (int i = 0; i < arrays1.length-1; i++) {
            for (int j = arrays1.length-1; j > i; j--) {
                if (arrays1[j-1]>arrays1[j]){
                    swap(arrays1[j],arrays1[j-1]);
                }
            }
        }

四、Arrays类的常用方法

        //Arrays方法的使用
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

五、面向对象

1、什么是面向对象、构造器

以类的方式组织代码，以对象的组织封装数据。 

构造器的使用：

public class Person {
    String name;
    int age;

    //构造器，无参构造
    public Person() {
    }

    //有参构造：实例化对象初始值
    //一旦定义了有参构造，就一定要声明无参构造
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
}

2、封装

程序要讲究“高内聚，低耦合”，封装的核心是属性私有，get/set。

public class Person {
    private String name;
    private int age;

    //构造器，无参构造
    public Person() {
    }

    //有参构造：实例化对象初始值
    //一旦定义了有参构造，就一定要声明无参构造
    //Alt+Insert
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 100 || age <1){
            this.age = 18;
        }else {
            this.age = age;
        }
    }
}

封装的作用：

（1）提高程序的安全性，保护数据。

（2）隐藏代码的实际细节

（3）统一接口

（4）系统可维护性提高 

3、继承

extends:子类可以使用父类的所有方法，但是私有属性必须通过get/set方法访问。所有类都默认继承Object类。

super:
1、super调用父类的构造方法，必须在构造方法的第一个
2、super 必须只能出现在子类的方法或者构造方法中!
3、super和 this 不能同时调用构造方法!

this:
代表的对象不同:
        this: 本身调用者这个对象
        super:代表父类对象的应用
前提：
        this:没有继承也可以使用
        super: 只能在继承条件才可以使用
构造方法：
        this() ;本类的构造
        super():父类的构造!

重写（Alt+Insert）：需要有继承关系，子类重写父类方法

1、方法名必须相同

2、参数列表必须相同

3、修饰符范围可以扩大，不能缩小：public>protected>Defult>private

4、抛出的异常可以缩小，不能扩大：Exception(大) ==> ClassNotFoundException

子类重写的方法与父类只有方法体不同。

为什么需要重写：父类的方法子类不一定需要或不满足。 

4、多态

1、只有方法才有多态，属性没有多态

2、存在条件：继承关系，方法需要重写，父类引用指向子类对象: father f = new son(); 

3、instanceof及强制转换

//判断对象与类之间是否存在继承或被继承的关系
System.out.println(b1 instanceof B);
//强制类型转换，将父类对象强制转换为子类对象，以便使用子类方法
((B)b2).eat();

5、抽象类和抽象方法

public abstract class Demo10 {

    //没有方法体，必须由继承的子类重写方法
    //抽象类中可以写普通的方法，但非抽象类中不能写抽象方法
    //不能new，只能靠子类去实现
    public abstract void print();
}

6、接口

//interface接口
public interface UserService {

    //默认抽象方法
    void add();
    void delete();
    void update();
    void query();
}

public interface TimerService {
    void timer();
}

//接口实现类，implements
//必须重写接口的方法
//可以多继承
public class UerServiceImpl implements UserService, TimerService {
    public UerServiceImpl() {
        super();
    }

    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }

    @Override
    public void timer() {

    }
}

 作用：

1、约束
2、定义一些方法，让不同的人实现
3、public static final
4、接口不能被实例化，接口中没有构造方法
5、implements可以实现多个接口
6、必须要重写接口中的方法

六、异常

public class Demo11 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        //捕获异常，往往用于IO、资源的关闭  Ctrl+Alt+T
        try{
            new Demo11().run(a,b);
        }catch (Exception e){
            e.printStackTrace(); //打印错误的栈信息
        }finally {
            System.out.println("finally");
        }
    }

    //throw、throws抛出异常，用于方法
    public void run(int a,int b) throws Exception{
        if (b == 0){
            throw new Exception();
        }
    }

}

 七、常用类

1、Object类

（1）toString()，equals()都是与地址值直接相关，而我们往往需要具体的变量，故需要对该类方法进行重写（toString()可以右键）。

（2）clone()：被克隆的对象需要实现接口Cloneable，然后再重写clone()类，之后才可被新建的对象调用

浅克隆：基本数据类型和引用数据类型（地址）都拷贝过来，Object的clone是浅克隆。

深克隆：把基本数据类型拷贝过来，会建立新的引用数基础类型。

3、 Random类

1、public Random（）

此构造方法是以系统自身的时间为种子数来构造Random对象。

2、public Random（long seed）

此构造方法可以手动选定具体的种子来构造Random对象。

使用方式：

new一个Random对象，用nextInt()方法赋值。

        //Random类
        Random random = new Random();
        int r = random.nextInt();
        System.out.println(r);
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Random r1 = new Random(n);
        System.out.println(r1.nextInt());

4、包装类

即基本数据类型对应的对象，在JDK5以后，提出自动装箱和自动拆箱的机制。

自动装箱：将基本数据类型自动转换为对象的包装类

自动拆箱：将包装类自动转换为对应的基本数据类型

包装类应用于数据转换：

        //将整数转换为二进制
        String  n1 = Integer.toBinaryString(200);
        System.out.println(n1);

        //将整数转换为八进制
        String  n2 = Integer.toOctalString(200);
        System.out.println(n2);

        //将整数转换为八进制
        String  n3 = Integer.toHexString(200);
        System.out.println(n3);

        //转换为整数
        //注意：每一种类型都有对应的parseXxx进行转换
        int n4 = Integer.parseInt("999");
        System.out.println(n4);

        String s = "true";
        boolean n5 = Boolean.parseBoolean(s);
        System.out.println(n5);

注意：以后默认输入就用nextLine()。

public class Demo13 {
    public static void main(String[] args) {
        //Integer应用于键盘输入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据：");
        String str = sc.nextLine();
        double v = Double.parseDouble(str);
        System.out.println(v+1);

    }
}

5、SimpleDateFormat

 作用：把时间变成合适的格式；把字符串表示的时间变成Date对象。

时间格式：yyyy-MM-dd HH:mm:ss  或  yyyy年MM月dd日 HH:mm:ss

时间格式化：

public class Demo14 {
    public static void main(String[] args) {

        //无参构造
        SimpleDateFormat sf1 = new SimpleDateFormat();
        Date d1 = new Date(System.currentTimeMillis());
        String str1 = sf1.format(d1);
        System.out.println(str1); //1970/1/1 上午8:00

        //有参构造
        SimpleDateFormat sf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
        Date d2 = new Date(System.currentTimeMillis());
        String str2 = sf2.format(d2);
        System.out.println(str2);
    }
}

6、Calendar类

注意：Calendar是一个抽象类，不能直接new，而是通过静态方法获取子类对象（getInstance()）

1、会通过不同时区来获取不同的日历对象，默认表示当前时间。

2、会把时间当中的字段放到一个数组中。

 

 3、获取日历的某个字段信息

public class Demo15 {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println(c);

//        //修改时间
//        Date d = new Date(0L);
//        c.setTime(d);
//        System.out.println(c);

        //获取日历的某个字段信息
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DAY_OF_MONTH);
        int week = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(year + "年" + month + "月" + date + "日" + " " + getWeek(week));
    }

    public static String getWeek(int week){
        switch (week){
            case 0: return "";
            case 1: return "星期日";
            case 2: return "星期一";
            case 3: return "星期二";
            case 4: return "星期三";
            case 5: return "星期四";
            case 6: return "星期五";
            case 7: return "星期六";
            default: return "无";
        }
    }
}

4、修改和增加

7、JDK8时间类

 8、StringBuilder类

 可以看作一个容器，创建的内容是可变的，提高字符串的操作效率。

作用场景：

1、字符串的拼接

2、字符串的反转

StringBuilder的使用：

public class Demo16 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(