Java 初学，几条探索得出的笔记

static 修饰的东西带不带final
可以带

类与子类

被继承的是父类，由继承得到的类叫子类，子类具有父类的一切成员变量及方法，类只能单一继承，子唯父。

class Dad {     //定义父类Dad
    void dad1() {     //父类成员方法
        System.out.println("父类的成员方法执行");
    }
}
class Son extends Dad {    //定义子类Son继承于父类Dad
    void son1() {    //子类成员方法
    System.out.println("子类的成员方法执行");
    }
}
public class test {
    public static void main(String args[]) {
        Son son = new Son();
        son.dad1();
        son.son1();
    }
}
/*运行结果：
E:\mycode>javac q123.java

E:\mycode>java q123
父类的成员方法执行
子类的成员方法执行
*/

无参构造的作用是什么？

子类继承父类的时候会自动继承无参的构造函数。
如果父类里面已经有一个带有参数的构造函数了，那么系统不会自动为父类创建一个默认的无参构造函数，
此时没有写不带参数的构造函数的话，继承的时候就会报错，
因为系统不知道要继承哪个构造函数，必须明确的使用super()关键字来描述。
（super和this类似，但是super指向父类。子类的构造方法第一行有一个隐形的super()方法）
所以一般为了避免这种错误的发生，在有带多个构造函数的类里面都会写一个不带参数的构造函数。

私有化的构造方法如何创建对象？单例模式是什么？

在java中，对象的创建都是由构造方法实现的。
如果将构造方法私有化，根据private的用法，就只能在类的内部创建类的对象，
然后在类的内部提供一个public方法返回在类内部创建的对象，类的外部调用这个方法。
看代码,我们使用上面的思路获取这个类的对象

class Student {
    //私有化构造方法
    private Student() {}
    //创建一个对象
    private static Student student = new Student();
    //提供public方法供外部访问，返回这个创建的对象
    public static Student getStudent(){
        return student;
    }
}
public class Test {
    public static void main(String[] args) {
        Student cxk  = Student.getStudent();
        //输出对象的地址，如果有地址存在，则说明对象创建成功并获取到
        System.out.println(cxk);
    }
}
/*运行结果：
E:\mycode>javac Student.java

E:\mycode>java student
Student@6d06d69c
*/

这里说明我们已经成功创建了构造方法被私有化的类的对象，
这种方式就是 单 例 模 式 ，可以再验证一下，创建的对象是否为同一个对象

public class Student {
    public static void main(String[] args) {
        Student cxk = Student.getStudent();
        Student cyl = Student.getStudent();
        //如果结果为true，则说明是同一个对象
        System.out.println(cxk==cly);
    }
}
class Student {
    //私有化构造方法
    private Student() {}
    声明引用数据类型并创建一个对象
    private static Student student = new Student();
    //提供public方法供外部访问
    public static Student getStudent(){
        return student;
    }
}
/*运行结果：
E:\mycode>javac Student.java

E:\mycode>java Student
true
*/

可以看出，每次获取到的对象都是同一个对象，
这就是单例模式中的饿汉模式，不管是否调用，都创建一个对象。

单例模式_定义：

是指在内存中只会创建且仅创建一次对象的设计模式。
在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，
单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。
单例模式有两种类型：
饿汉式：在类加载时已经创建好该单例对象，等待被程序使用,如以上例子
懒汉式：在真正需要使用对象时才去创建该单例类对象，如以下例子

public class Student {
    private static Student student;    //声明引用数据类型
    
    private student() {}
    
    public static Student getStudent() {
        if (student == null) {
            student = new Student();    //创建对象
        }
        return student;
}

类没有方法会怎么样

会形成空类，不影响程序的编译和运行。

尝试在String和整型之间做切换（java中整型与字符串型之间的转换）

字符串型转换成整型：

1.转换成Int型

int/Integer num = Integer.parseInt(String str);

2.转换成long型

Long/long num = Long.parseLong(String str);

3.转换成short型

short/Short num = Short.parseShort(String str);

4.转换成float型

float/Float num = Float.parseFloat(String str);

整型转换成字符串型

1.整型转换成字符型

String num = Integer.toString(int n);

2.Long型转换成字符型

String num = Long.toString(long n);

3.Short型转换成字符型

String num = Short.toString(Short n);

4.Float型转换成字符型

String num = Float.toString(Float n);

java的逻辑运算符

（逻辑与）短路与 && ：只要第一个条件为假，后面的条件就不会被检查。 if( A && B )
尽量把更可能为假的条件放前面，减少程序的运行

（逻辑或）短路或 || ：只要第一个条件为真，后面的条件就不会被检查。 if( A || B )
尽量把更可能为真的条件放前面，减少程序的运行

（布尔逻辑与）按位与 & ：每一个条件都会被检查、执行。 if((b=44)&(a>3))

（布尔逻辑或）按位或 | ：每一个条件都会被检查、执行。 if((b=44)|(a>3))

异或(^)：同真同假时结果为假，否则为真

java的位运算符

<<  表示左移，不分正负数，低位补0，高位舍弃
>>  表示右移，如果该数为正，则高位补0，若为负数，则高位补1，低位舍弃
>>> 表示无符号右移，也叫逻辑右移，右移后高位补0

<< 1  相当于乘以2
>> 1  相当于除以2
>>> 不考虑高位的正负号，正数的 >>> 等同于 >>

二进制数相加

0101—>5
1001—>9
1110—>14 （按位相加，满2进1）

无static修饰的方法用对象去调，有static修饰的方法用类名去调