JavaSE基础学习笔记

类与对象

String和基本类型互转的方式：

String -> int：加双引号；String.valueOf(num)
int -> String：Integer.parseInt(num)；new Integer(num)

如何创建不确定列数的二维数组

类的五大成员是什么？

找一道递归的题目做一下

方法中的可变参数

//调用方法后，直接在形参填入数字即可
public void f1(int...nums)

怎么复用构造器？用this关键字

OOP

封装：将属性私有化，即给属性添加set/get方法

继承

子类构造器的第一行会调用父类的构造器（优先调用无参）
在子类构造器中，super和this不能同时使用

多态：对象或方法具有多种形态

方法的多态：重载或者重写就体现了多态
对象的多态：
- 向上转型：Animal animal = new Cat(); 向上转型的对象只能调用父类中的方法
- 向下转型：Animal animal = new Cat(); Cat cat = (Cat) animal; 向下转型的对象能够调用父类和子类的方法
属性没有多态，向下/向下转型对象的属性值看编译类型

方法重写：返回类型、方法名、参数列表跟父类方法一样

方法重载：方法名一样，形参的类型、个数、顺序至少有一个不同

Util包的方法：Arrays.sort()；有序排序

instanceOf比较操作符

//判断a是否为A类型或者A的子类型
System.out.println(a instanceOf A);

OOP（高级）

什么是类变量和类方法？

类方法中只能使用类变量和类方法，不能使用this、super或其他的

内部类

局部内部类（有类名、定义在方法中，外部其他类无法访问）

内部类成员和外部类成员重名时，就近原则（特定访问外部类名.this.成员）

//调用局部内部类中的方法：1.通过内部类中创建对象来调用
public class Review{
    public static void main(String[] args) {
        Out out = new Out();
    	out.hi();
    }
}
class Out{
    public void hi(){
        class Inner{
            public void f1(){
                System.out.println("f1");
            }
            public void f2(){
                System.out.println("f2");
            }
        };
        Inner inner = new Inner();
        inner.f1();
        inner.f2();
    }
}

匿名内部类（没类名、定义在方法中，外部其他类无法访问）

匿名内部类需要基于一个外部的类/抽象类/接口

//调用匿名内部类中的方法：1.通过类名接收，再用类名调用；2.直接调用；
//基于类/抽象类/接口的匿名内部类
public class Review{
    public static void main(String[] args) {
        Out out = new Out();
        out.h1();
        out.h2();
        out.h3();
    }
    /*
        输出
        h1.f1
        h2.f1

     */
}
class Out{
    //通过类名调用匿名内部类的方法
    public void h1(){
        B b = new B(){
            @Override
            public void f1(){
                System.out.println("h1.f1");
            }
        };
        b.f1();
    }
    //直接调用内部类中的方法
    public void h2(){
        new B(){
            @Override
            public void f1() {
                System.out.println("h2.f1");
            }
        }.f1();
    }
    //不重写直接调用
    public void h3(){
        new B().f1();
    }
}
//内部类要基于一个类或抽象类或接口
class B{
    public void f1(){}
}

成员内部类（有类名、定义在成员位置上，外部其他类可以通过对象名访问）

//调用方法：
public class Review{
    public static void main(String[] args) {
        Out out = new Out();
        Out.Inner inner = out.new Inner();//看清楚
        inner.f1();
    }
}
class Out{
    class Inner{
        public void f1(){
        	System.out.println("f1");
        }
    }
}

静态内部类

只能访问外部类的静态成员

静态内部类成员和外部类成员重名时，就近原则（特定访问用外部类.成员，注意和局部内部类区分）

public class Review{
    public static void main(String[] args) {
        Out out = new Out();
        Out.Inner inner = out.new Inner();
        inner.info();
        
//        Out out = new Out();
//        Out.Inner inner1 = out.getInner();
//        inner1.info();
    }
    /*
        输出
        tom 12
        jack 18
     */
}
class Out{
    public static int age = 18;
    public static String name = "jack";
    class Inner{
        public int age = 12;
        public String name = "tom";
        public void info(){
            System.out.println(name+" "+age);
            System.out.println(Out.name+" "+Out.age);
        }
    }
    
//    public Inner getInner(){
//        return new Inner();
//    }
}

代码块

代码块的用处？有语句在每次创建对象时，需要重复的执行时，可用代码块

静态代码块只有在类加载（创建对象/子类对象/使用静态成员）时会执行一次

普通代码块在每次创建对象时都会执行

单例设计模式

设计步骤：1.私有化属性；2.私有化构造器；3.创建对象的语句（私有化静态的）；4.返回对象的方法（静态的）

饿汉式
懒汉式

区别：饿汉式在每次类加载时都会创建一个对象，会浪费空间；

懒汉式只有在执行返回对象方法时才会创建对象

接口

接口可以多实现，接口不能继承其他类，但是可以继承其他接口

接口中的方法都是Public的

抽象类

抽象类中可以没有抽象方法

枚举

枚举类的两种实现方式

自定义类实现枚举类

私有化属性
私有化构造器
创建公开的get方法
创建公开的静态的对象

public class Review01 {
    public static void main(String[] args) {
        System.out.println(Week.MONDAY);
        System.out.println(Week.TUESDAY);
        System.out.println(Week.WEDNESDAY);
    }
    /**
     * 自定义类实现枚举类
     *
     * Week{day='monday'}
     * Week{day='tuesday'}
     * Week{day='wednesday'}
     */
}
class Week{
    private String day;
    private Week(String day) {
        this.day = day;
    }
    public static Week MONDAY = new Week("monday");
    public static Week TUESDAY = new Week("tuesday");
    public static Week WEDNESDAY = new Week("wednesday");
    public String getday() {
        return day;
    }
    @Override
    public String toString() {
        return "Week{" +
                "day='" + day + '\'' +
                '}';
    }
}

enum关键字实现枚举类（推荐，优点：可以使用enum方法，如values(),name()）

私有化属性
私有化构造器
创建set方法
创建对象（ps:要放在首行位置）

public class Review {
    public static void main(String[] args) {
        Week[]  weeks = Week.values();
        for (Week week : weeks) {
            System.out.println(week);
        }
    }
    /**
     * enum关键字实现枚举类
     *
     * 输出
     * MONDAY
     * TUESDAY
     */
}
enum Week{
    MONDAY("monday"),
    TUESDAY("tuesday");
    private String day;
    private Week(String day) {
        this.day = day;
    }
    public String getDay() {
        return day;
    }
    @Override
    public String toString() {
        return name();
    }
}

两种方式的写法区别：创建对象的语句不同，语句位置不同，类名不同

异常

5种常见的运行时异常

NullpointerException 空指针异常
ArithmeticException 运算异常
ArrayIndexOutOfBoundsException 数组越界异常
ClassCastException 类型转换异常
NumberFormatException 数字格式不正确异常

异常处理方式

try-catch-finally 自行处理
throws 交给调用者处理

常用类

String类

final String[] Str = {"a","b"}; final String数组能够改变数组中的值，但不能改变数组指向的地址

String.format("%.2s","jack"); 显示前两位；s：字符串、c：字符、d：整型、f：浮点型

日期Date

public class Review {
    public static void main(String[] args) {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        String s = dtf.format(LocalDateTime.now());
        System.out.println(s);

        LocalDate ld = LocalDate.now();
        System.out.println(ld);
    }
    /**
     * 输出
     * 2022-07-06 01:27:36
     * 2022-07-06
     */
}

BigInteger（较大整型）和BigDecimal（精度较高浮点型）

加减乘除用add、subtract、multiply、divide方法

public class Review {
    public static void main(String[] args) {
        BigInteger b1 = new BigInteger("100");
        BigInteger b2 = new BigInteger("5");
        System.out.println(b1.add(b2));
        System.out.println(b1.subtract(b2));
        System.out.println(b1.multiply(b2));
        System.out.println(b1.divide(b2));
    }
    /**
     * 输出
     * 105
     * 95
     * 500
     * 20
     */
}

Arrays类的常见方法

StringBuffer和StringBuilder

StringBuffer和StringBuilder 跟 String比的优点：String是不可变的，每次发生变动都得重新创建一个字符，而StringBuffer和StringBuilder是可变的。

String：效率低，复用率高（字符串变动少，多次引用时用）
StringBuffer：效率较高，线程安全（多线程时用）
StringBuilder：效率最高，线程不安全（单线程是用）

StringBuffer和StringBuilder的方法是一样的。

public class Review {
    public static void main(String[] args) {
//        String -> StringBuffer
        String s = "jack";
//        方式1：使用构造器(推荐）
        StringBuffer sb = new StringBuffer(s);
        System.out.println(sb);
//        方式2：使用append方法
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = sb1.append(s);
        System.out.println(sb2);

//        StringBuffer -> String
        StringBuffer Strb = new StringBuffer("你好");
//        方式1：使用构造器（推荐）
        String s1 = new String(Strb);
        System.out.println(s1);
//        方式2：使用StringBuffer的toString方法
        String s2 = Strb.toString();
        System.out.println(s2);
    }
    /**
     * jack
     * jack
     * 你好
     * 你好
     */
}

posted @ 2022-10-09 15:23 小明吖阅读(39) 评论(0) 收藏举报

刷新页面返回顶部

JavaSE基础 学习笔记