java基础知识和语法

1.类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能

对象准备创建时，也会自动调用代码块，但不是静态的；

public class java_3_24
{
    public static void main(String[] args) {
    new User08();
    }

}
class User08{
    static {
        System.out.println("静态代码块执行1");
    }
    static {
        System.out.println("静态代码块执行2");
    }
    static void test(){
        System.out.println("test...");
    }
    {
        System.out.println("代码块执行");
    }
    static {
        System.out.println("静态代码块执行3");
    }
}

注意：先调用静态代码块，再调用了代码块，这是准备创建的情况，既会调用代码块，也会调用静态代码块；

public class java_3_24
{
    public static void main(String[] args) {
    User08.test();   //因为test是静态方法，所以可以通过类名直接调用；
    }

}
class User08{
    static {
        System.out.println("静态代码块执行1");
    }
    static {
        System.out.println("静态代码块执行2");
    }
    static void test(){
        System.out.println("test...");   
    }
    {
        System.out.println("代码块执行");
    }
    static {
        System.out.println("静态代码块执行3");
    }
}

这是信息加载的情况，只会调用静态代码块；

2.包：package;

在包之中容纳类，调用包中的类：

java.lang.Object;

主要目的是分类管理；类可以没有包；

包的声明语句只能在一个源码文件中使用一次；

包名一般都是小写；

3.一般情况下，使用类时，都会使用类的全名：包名+类，但有例外：

（1）使用的类就在本包中，无需全名；

（2）java.lang中的类，无需全名;

（3）事先import一个类，也无需全名；

例如：

import java.util.Date;
public class java_3_24
{
    public static void main(String[] args) {
    Date d = new Date();
    }

}

但import在使用时有需要注意的地方：

（1）import语句只能用于package后，class前；

（2）import可以多次使用，导入多个类；

如果要导入多个类，可以使用通配符*来操作：

import java.util.*;
public class java_3_24
{
    public static void main(String[] args) {
    Date d = new Date();
    }

}

4.构建对象：

构造方法：在一个类中如果没有自己设置创建方法，那么JVM会自动添加一个公共的，无参的构造方法，方便使用；

（1）构造方法也是方法，但没void关键字；

（2）方法名和类名完全相同；

（3）构造方法可以传递参数，但是一般传递参数的目的是用于对象属性的赋值；

例如：

public class java_3_24
{
    public static void main(String[] args) {
        System.out.println("before");
        User11 user = new User11();
        System.out.println("after");
        user.test();
    }

}
class User11{
    User11(){
        System.out.println("user...");
    }
    void test()
    {
        System.out.println("test...");
    }
}

在定义构造方法的同时，打印一个user；

例如:

public class java_3_24
{
    public static void main(String[] args) {
        User11 user = new User11("zhangsan");
        System.out.println(user.username);


    }

}
class User11{
    String username;

    User11(String name){
        username = name;

    }

}

打印结果为zhangsan；

5.面向对象编程中有3个非常重要的特征：继承，封装，多态；

下面介绍继承：

（1）类存在父子关系：子类可以直接获取到父类的成员属性和成员方法。

（2）类的继承只能单继承一个父类；

（3）一个父类可以有多个子类；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        Child c = new Child();
        System.out.println(c.name);
        c.test();
        };
    }


class Parent{
    String name = "zhangsan";
    void test(){
        System.out.println("test...");
    }
}
class Child extends Parent{

}

6.如果父类和子类含有相同的属性，那么可以采用特殊的关键字来区分：

super & this. 例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        Child c = new Child();
        c.test();
        };
    }


class Parent{
    String name = "zhangsan";

}
class Child extends Parent{
    String name = "lisi";
    void test(){
        System.out.println(super.name);
        System.out.println(this.name);
    }
}

父子类中的构造方法:

父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建

默认情况下，子类对象创建时，会默认调用父类的构造方法完成父类对象的创建，使用的是super方法；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        Child c = new Child();

        };
    }


class Parent{
    Parent(String name){
        System.out.println("parent...");
    }

}
class Child extends Parent{
    Child() {
        super("zhangsan");
        System.out.println("child...");
    }
}

父类要求传参才能构建，所以这时省略super方法就行不通了，所以要手动的进行传参，注意super方法时在子类的构建方法中调用的；

7.多态：

所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态；

多态语法其实就是对对象的使用场景进行了约束；

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        Person p = new Person();
        p.testperson();
        Person p1 = new Boy();
        p1.testperson();
        p1.testboy();   //会报错
        Person p2 = new Girl();
        p2.testgirl();  //会报错
        

        };
    }
class Person{
    void testperson(){
        System.out.println("testperson");
    }
}
class Boy extends Person{
    void testboy(){
        System.out.println("testboy");
    }

}
class Girl extends Person{
    void testgirl(){
        System.out.println("testgirl");
    }
}

一个对象可以使用的功能取决于引用变量的类型；上面的p1和p2都是person类型，所以可以引用person的功能；

8.一个类中，不能重复声明相同的方法（方法名、参数列表，但是和返回值类型无关），也不能声明相同的属性；

如果方法名相同，但参数列表不同，会被认为是不同的方法，只不过名称一样，这个操作在java中称之为方法的重载；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        User14 user = new User14();
        user.login(12321);
        user.login("nima", "cnm");
        user.login("123123");
    }

    }
class User14{
    void login(String account, String password){
        System.out.println("账号密码登录");
    }
    void login(int tel){
        System.out.println("手机号登录");

    }
    void login(String vx){
        System.out.println("weixin登录");
    }

}

三个方法名字相同，执行不同功能；

9.方法的重载：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        User12 user = new User12();


    }


}
class User12{
    User12(){
        this("zhangsan");

    }
    User12(String name){
        this(name, "男");
    }
    User12(String name, String sex){
        System.out.println(name + "," + sex);
    }
}

当调用无参构造方法时，用this来调用自身的构造方法，并传入参数，再调再传，然后执行打印操作；

10.匹配方法时的精度扩大：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        byte b = 10;
        test(b);


    }
    static void test(byte b){
        System.out.println("bbb");
    }
    static void test(short s){
        System.out.println("sss");
    }
    static void test(char c){
        System.out.println("ccc");
    }
    static void rest(int i){
        System.out.println("iii");
    }
}

此时打印bbb没毛病，但当我去掉test（byte b）这个方法时，就会打印sss，这是因为byte类型扩大精度优先转换为容易转换的类型；

注意：byte类型无法和char类型转换，因为byte类型有负数，而char类型没有负数；

11.重载和多态的综合:

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        AAA aaa = new AAA();
        BBB bbb = new BBB();
        test(bbb);


    }
    static void test(AAA aaa){
        System.out.println("aaa");
    }

}
class AAA{

}
class BBB extends AAA{

}

打印结果为aaa，因为当前test方法应该接受AAA类型，但传入BBB类型，就会发生类似于基本类型的精度提升，只不过这里是从子向父提升；

12.方法的重写：父类对象的方法其实主要体现通用性，无法在特殊的场合下使用；

如果子类对象需要在特殊场合使用，那么需要重写方法的逻辑，这个操作在java中称为方法的重写；（并不影响父类的方法，使用super类型还是可以访问）；

重写方法：子类的方法和父类的方法，方法名相同，返回值类型相同，参数列表要相同；

总结：（1）一个对象使用什么方法，取决于引用变量的类型；

（2）一个对象能使用什么属性，取决于引用变量的类型；

（3）一个对象的方法具体的使用是需要看具体的对象的；

（4）一个对象的属性具体的使用是不需要看具体的对象的，属性在哪里声明就在哪里使用；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    CCC ddd = new DDD();
        System.out.println(ddd.sum());


    }

}
class CCC{
    int i = 10;
    int sum(){
        return i + 10;
    }
}
class DDD extends CCC{
    int i = 20;
    int sum(){
        return i + 20;
    }
}
ddd是CCC类型，所以应该看CCC中有没有sum方法，有，那么能使用，但具体的实现过程是依靠DDD中的sum方法，所以输出结果为40；

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    CCC ddd = new DDD();
        System.out.println(ddd.sum());


    }

}
class CCC{
    int i = 10;
    int sum(){
        return i + 10;
    }
}
class DDD extends CCC{
    int i = 20;

}

当把子类中的sum类型去掉后，方法具体的实现在子类中没有，那么去父类中寻找，父类的sum实现时，默认使用的是this属性，也就是父类中的属性，所以结果为20；

再看：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    CCC ddd = new DDD();
        System.out.println(ddd.sum());


    }

}
class CCC {
    int i = 10;

    int geti() {
        return i;
    }

    int sum() {
        return geti() + 10;
    }
        


    }
    class DDD extends CCC {
        int i = 20;

        int geti() {
            return i;
        }

    }

这串代码中，首先运行sum，在子类中没办法实现，最终要落回父类，再执行geti方法，这个需要子类中的方法进行实现，所以最终打印30；

13.访问权限：

public:公共的，访问权限修饰符，java源码中，公共类只能有一个，而且必须和源码文件名相同；

（1）private：私有的，同一个类中可以使用；

（2）（default）：默认权限，不设定时默认设定，同类同包可用；

（3）protected：受保护的：同包，同类，子类可用；

（4）public：公共的，任意使用；

14.Java中不允许外部类使用private，protected修饰；

所谓外部类，就是在源码中直接声明的类；

所谓的内部类，就是类中声明的类；

注意：内部类就当成外部类的属性使用即可，因为内部类可以看做内部类的属性，所以需要构造外部类对象才可以使用；

例如：内部类的创建过程：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    OuterClass outer = new OuterClass();
    OuterClass.InnerClass innerClass = outer.new InnerClass();
    


    }

}
class OuterClass{
    public class InnerClass{
        
    }
}

15.类的单一创建：单例模式：

由于类的创建过程复杂，如果在外部直接创建类的对象，可能会丢失一些结构，使对象使用出现问题；

还有就是类占用内存较大，我们尽可能少创建类的对象，所以我们可以把类的构建方法进行private修饰，那么就只能在类中构建了；同时再加上if语句做判断，那么就保证了一个类只会产生一个对象；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    User19 instance = User19.getInstance();
    }

}
class User19{
    private static User19 user19 = null;
    private User19(){

    }
    public static User19 getInstance(){
        if(user19 == null){
            user19 = new User19();
        }
        return user19;
    }
}
在这串代码中，创建了一个user19作为属性，然后设计getinstance方法，实现了在类的内部创建对象；

其中，由于静态方法只能访问静态属性，非静态方法既可以访问静态也可以访问非静态属性，那么就需要给属性前加上static；

16.Java中提供了一种语法，可以在数据初始化后不被修改，使用关键字final；

final可以修饰变量；变量的值一旦初始化后无法修改。

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    final String name = "zhangsan";
    name = "lisi";
    }

}

会发生报错；

（1）final可以修饰变量：变量的值一旦初始化后无法修改；

（2）final可以修饰属性：那么JvM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化；

（3）final可以修饰方法，这个方法不能被子类重写；

（4）final可以修饰类，这样的类就没有子类了；

（5）final不可以修饰构造方法

（6）final可以修饰方法的参数，一旦修饰，参数就无法修改了；