【无标题】

Java基础语法-面向对象

---

一.面向对象 - 静态

1.1 基本概念

把和对象无关，只和类相关的称之为静态
和类相关的属性称之为静态属性
和类相关的方法称之为静态方法
静态语法就是在属性和方法前面增加static关键字

1.2 简单案例

1.2.1 静态方法的简单实现

静态方法可以不用创建对象，通过类名直接访问。

1.2.2 代码呈现

​
public class Java08_Object_Static {
    public static void main(String[] args) {
        Bird.fly();
        System.out.println(Bird.name);
    }
}
class Bird{
	// 静态属性
    static String name = "鸟";
    // 静态方法
    static void fly(){
        System.out.println("飞...");
    }
}

1.2.3 代码结果：

飞…
鸟

1.3 当同时有成员方法和静态方法时：

当一个类里面同时拥有成员属性和静态属性，以及成员方法和静态方法时，它们之间可以互相调用吗？

1.3.1 代码呈现：

public class Java08_Object_Static_1 {
    public static void main(String[] args) {
        Test t = new Test();
        Test.sex = "女";
        t.test();
    }
}
class Test{
    //成员属性
    String name;
    //静态属性
    static String sex;
    // 成员方法 和对象相关
    void test(){
        test1();
    }
    //静态方法 和当前的类相关
    static void test1(){
        System.out.println("test1" + "," + sex);
    }
}

1.3.2 代码结果：

test1,女

1.4 小结：

当在静态方法里面访问成员属性或者方法是，会提示报错。所以成员方法可以访问静态属性和静态方法，但是静态方法不可以访问成员属性和成员方法

1.5 静态代码块

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

1.5.1 代码呈现：

public class Java08_Object_Static_2 {
    public static void main(String[] args) {
        User08.test();
        // 对象准备创建时，会自动调用代码块，但不是静态的
        //new User08();
    }
}

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

1.5.2 代码结果：

静态代码块执行1
静态代码块执行2
静态代码块执行3
test

1.5.3 产生的问题

问题：java中类的信息加载完成后，明明静态方法写在前面，为什么先自动调用静态代码块，再调用静态方法？

1. 初始化顺序：Java确保在类的任何静态方法被调用之前，类的静态字段和静态代码块已经被正确地初始化。这是通过类的初始化过程来保证的。
2. 代码块的作用：静态代码块通常用于执行必须在类被首次使用之前完成的初始化操作。它们提供了一种机制来设置类的静态状态。
3. 静态方法的调用：静态方法可以在类的静态代码块执行之后被调用。然而，由于静态代码块在类加载和初始化期间自动执行，因此它们在逻辑上先于任何静态方法的显式调用。
4. 可见性和封装：静态代码块提供了一种在类的外部不可见的方式来设置类的静态状态。这使得它们成为封装和隐藏实现细节的有用工具。

注：如果创建一个对象时，会自动调用类中的代码块，但不是静态的。
总结：当你在Java中编写代码时，你应该意识到静态代码块和静态方法的初始化顺序，并确保你的代码依赖于这个顺序。如果你需要在一个静态方法之前执行某些初始化代码，那么你应该将这些代码放在一个静态代码块中。

二.面向对象 - 继承

2.1 基本概念

类存在父子关系： 子类可以直接获取到父类的成员属性和成员方法
类的继承只能是单继承，一个类只能有一个父类，不能存在多个父类
一个父类可以有多个子类
继承采用extends语法： 子类 extends 父类

2.2 简单案例

2.2.1 继承的简单代码呈现

public class Java12_Object_Extends {
    public static void main(String[] args) {
        Son s = new Son();
        // 继承了父类的属性
        System.out.println(s.name);
        // 继承了父类的方法
        s.test();
    }
}

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

class Son extends Father{

}

2.2.3 输出结果

zhangsan
test

2.3 当父类和子类都含有相同属性时，怎样区分用的调用的是哪个类中的属性

可以采用特殊的关键字 super & this

2.3.1 代码

public class Java12_Object_Extends_1 {
    public static void main(String[] args) {
        Son1 s = new Son1();
        s.test();
    }
}

class Father1{
    String name = "zhangsan";
}
class Son1 extends Father1{
    String name = "lisi";

    void test(){
    	// super.name 表示调用的父类中的name属性
        System.out.println(super.name);
        // this表示当前类 默认情况下 System.out.println(name) = System.out.println(this.name);
        System.out.println(this.name);
    }
}

2.3.2 输出结果

zhangsan
lisi

2.4 当类中含有构造方法时

父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建
默认情况下，子类对象创建时，会默认掉用父类的构造方法完成父类对象的创建。使用的是super的方式，只不过JVM自动完成
如果父类提供构造方法，那么JVM不会提供默认的构造方法，那么子类应该显示调用super方法构建父类对象

2.4.1 代码

public class Java12_Object_Extends_2{
    public static void main(String[] args) {
        Son3 s = new Son3();
    }
}

class Father3{
    String name;

//    Father3(){
//        System.out.println("father");
//    }
    
    Father3(String name) {
        this.name = name;
        System.out.println("father");
    }
}

class Son3 extends Father3{

    Son3() {
    	// 当父类提供的是无参构造方法时，此时的子类会默认调用父类的构造方法
    	// 当父类提供的构造方法不是无参时，子类应该显示调用super方法构建父类对象
        super("zhangsan");
        System.out.println("son");
    }
}

2.4.2 输出结果

father
son

三.面向对象 - 多态

3.1 基本概念

所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态
多态语法其实就是对对象的使用场景进行了约束
一个对象可以使用的功能取决于引用变量的类型

3.2 简单案例

3.2.1 代码

public class Java13_Object{
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.test();
        Person p2 = new Boy();
        p2.test();
        // 以父类声明的子类对象，只能使用父类中的方法
        // 所以 p2.testBoy(); 会报错
        Person p3 = new Girl();
        p3.test();

        Boy boy = new Boy();
        boy.testBoy();
    }
}

class Person{
    void test(){
        System.out.println("test person...");
    }
}

class Boy extends Person{

    void testBoy(){
        System.out.println("test boy...");
    }
}

3.2.2 输出结果

test person…
test person…
test person…
test boy…

四. 面向对象 - 重载

4.1 基本概念

一个类中，不能重复声明相同的方法，也不能声明相同的属性，这里相同的方法指的是方法名，参数列表相同，和返回值类型无关
如果方法名相同，但是参数列表（个数，顺序，类型）不同，会认为是不同的方法，只不过名称一样
这样的操作在Java中成为方法的重载，构造方法也存在方法的重载

4.2 代码

public class Java14_Object{
    public static void main(String[] args) {
        User14 user = new User14("aaa");
        user.login(1234);
        user.login("1234");
        user.login("aaa","1234");
    }
}

class User14{
    User14(){
        System.out.println("user...");
    }

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

    void login(String wx){
        System.out.println("微信登录");
    }
}

4.3 输出结果

user…aaa
手机号登录
微信登录
账号，密码登录