2.2 java基础 day03 类和对象中的属性、方法、方法参数，静态方法static void xx{}，静态代码块static{}、代码块{},包，import

最新推荐文章于 2024-11-15 18:38:47 发布

fw学前端

最新推荐文章于 2024-11-15 18:38:47 发布

阅读量141

点赞数

分类专栏： java基础文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_56356342/article/details/128851788

版权

java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的类和对象，包括属性、方法、方法参数、静态方法和静态代码块的用法。讲解了属性的声明和初始化，方法的定义及返回值，以及方法参数的传递规则。此外，还阐述了静态方法的特点，静态代码块的执行时机，以及Java中的包管理和import语句的作用。

摘要由CSDN通过智能技术生成

属性：

所谓的属性，其实就是类的对象的相同特征。

语法和变量的声明很像。

属性类型属性名称 = 属性值

如果在声明属性的同时进行了初始化赋值，那么所有对象的属性就完全相同

所以如果希望每个对象的属性不一致，那么可以不用在声明属性的时候进行初始化。

那么属性会在构造对象的时候默认初始化，而默认初始化的值取决鱼属性的类型.

byte ,short, int ,long => 0

float, double => 0.0

boolean flg = false

char = 空字符

引用数据类型 => null

变量是方法的一部分作用域非常小，只在当前的大括号内有效

属性是对象的一部分不仅仅在当前类中有效，而且可以随着对象在其他地方使用

变量使用前必须初始化，否则会出现错误，属性可以不用初始化，因为JVM会帮助我们自动完成初始化。

方法：

        类的行为称之为方法。
        基本的语法为：void 方法名（）{ 方法的逻辑代码 }
        既然方法是对象的行为，那么行为就会有结果，而结果可能会对其他对象有影响
扩展语法：返回值类型[void] 方法名（）{ 方法的逻辑代码 }
        方法就是行为，所以会有结果，如果想要结果给其他人使用，那么需要在方法中返回这个结果。 void关键字表示无需返回，也就是方法的结果没有人使用。
        如果想要结果给其他人使用，那么需要在方法中返回结果，并将void改成返回值的类型。
方法的结果需要采用return关键字进行返回。

名词：类、属性

动词：方法（注意调用顺序，比如先注册后登录）

方法的调用方式：对象.方法名（）

案例：

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


        // TODO 面向对象 - 方法
        // 类的行为称之为方法。
        // TODO 基本的语法为：void 方法名（）{ 方法的逻辑代码 }
        // 既然方法是对象的行为，那么行为就会有结果，而结果可能会对其他对象有影响
        // TODO 扩展语法： 返回值类型[void] 方法名（）{ 方法的逻辑代码 }
        //  方法就是行为，所以会有结果，如果想要结果给其他人使用，那么需要在方法中返回这个结果。
        //       void关键字表示无需返回，也就是方法的结果没有人使用。
        //  如果想要结果给其他人使用，那么需要在方法中返回结果，并将void改成返回值的类型。
        //  方法的结果需要采用return关键字进行返回。


        User z1=new User();
        if (z1.register()){
            System.out.println("注册成功");
            if (z1.login()){
                System.out.println("登录成功");
            }else{
                System.out.println("登录失败");
            }
        }else{
            System.out.println("注册失败，请重新注册");

        }
    }
}
class User{
    Boolean register(){
        return true;
    }
    Boolean login(){
        return false;
    }
}

方法参数：

使用外部数据控制方法内部实现的操作（参数语法）

内部：方法名(参数类型参数名称)

外部：传递参数

当方法传递多个参数时，参数个数、类型、顺序都要匹配

当参数个数不确定，但类型相同时，可以采用可变参数语法声明

格式：参数类型… 参数名称（String… name）

如果方法头还包含其他类型参数，可变参数应声明在最后

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

        // TODO 面向对象 - 方法 - 参数
        // 从外部获取数据控制方法的内容逻辑实现的语法操作，我们称之为参数。也叫方法参数。
        // 方法的参数语法类似于变量：类型 名称，但是需要在方法后面的小括号中使用
        // 参数可以有多个，如果有多个，那么使用逗号隔开。
        // 如果方法声明了参数，那么调用时必须传递参数，否则发生错误。
        // TODO 扩展语法： 返回值类型[void] 方法名（参数类型 参数名）

        // 如果参数有多个的话，那么在传值的时候需要注意：
        // 1. 个数不能缺失
        // 2. 类型必须匹配
        // 3. 顺序必须匹配
        // 将方法后面的小括号中的所有参数称之为参数列表

        // 如果参数的类型(含义)相同，但是个数不确定的场合，JVM提供了可变参数 ： 参数的长度可变
        // 参数类型...参数名
        // 传值的个数也可以是变化的。

//        User07 user = new User07();
//        user.sayHello("zhangsan", 30);
//        user.sayHello(40, "lisi");
        User07 user = new User07();
        user.printUser(30);
        user.printUser(40, "zhangsan");
        user.printUser(50, "zhangsan", "lisi", "wangwu");

        // 如果参数列表中含有不同含义的多个参数，那么可变参数必须放置在最后，否则出现错误
    }
}
class User07 {

    //    void sayHello( String name, int age ) {
//        System.out.println("Hello "+name);
//    }
    //todo 可变参数
    void printUser( int age, String... name  ) {
        System.out.println(name); //要循环里面的内容才可以打印出来
        for(String i:name){
            System.out.println(i);
        }
    }
}

参数传值：

方法执行在栈内存中完成，在栈帧中存放参数、变量、执行逻辑

保持CPU箭头不变，调用新方法压栈、执行完方法弹栈

引用对象及属性存于堆中，调用新方法压栈时，传递箭头（同一个引用地址），但如果进行字符串拼接等操作，会创建一个新的字符串（指向新的引用地址）（传递对象修改属性不会），如果执行方法内的 s = s + 10，则新s 和原s 指向的不是同一个引用地址，因此，执行完毕后，会弹出方法内的新s 和引用地址，打印出的还是原s

Java 中方法参数的传递为值传递

基本数据类型传数值，引用数据类型传引用地址

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

        // TODO 面向对象 - 方法 - 参数
        // Java种方法参数的传递为值传递
        // 基本数据类型：数值
        // 引用数据类型：引用地址
//        String s = "abc";
//        test(s);
//        System.out.println(s);// abc10
        User user = new User();
        user.name = "zhangsan";
        test(user);
        System.out.println(user.name);

    }
//    public static void test(int i) {
//        i = i + 10;
//    }
//    public static void test(String s) {
//        s = s + 10;
//    }
    public static void test(User user) {
        user.name = "lisi";
    }
}
class User {
    String name;
}

静态：

静态方法：

针对于具体对象的属性称为对象属性，成员属性，实例属性

针对于具体对象的方法称为对象方法，成员方法，实例方法

static：和对象无关，只和类相关（可以通过类名. 直接访问）

先有类，再有对象

有成员方法的时候，静态方法（类）一定存在，因此可在成员方法内部调用静态方法/属性，但静态方法不能访问成员方法/属性

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

        // TODO 面向对象
        // 针对于具体对象的属性称之为对象属性，成员属性，实例属性
        // 针对于具体对象的方法称之为对象方法，成员方法，实例方法
        // 把和对象无关，只和类相关的称之为静态，
        // 和类相关的属性称之为静态属性
        // 和类相关的方法称之为静态方法
        // 静态语法就是在属性和方法前增加static关键字
        //Chinese c = new Chinese();
//        Chinese c = null;
//        c.name = "zhangsan";
//
//        System.out.println("Hello " + c.name + ", " + c.nationality);

        Bird.fly();
        System.out.println(Bird.type);
    }
}
class Bird {
    static String type = "鸟";
    static void fly() {
        System.out.println("飞...");
    }
}
class Chinese {
    String name;

    // 国籍
    String nationality = "中国";
}

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

        // TODO 面向对象 - 静态

        // TODO 先有类，再有对象。
        // 成员方法可以访问静态属性和静态方法
        // 静态方法不可以访问成员属性和成员方法
        Test t = new Test();
//        t.sex = "女";
//        t.test();
//        t.test1();
//        Test.test1();
    }
}
class Test {

    String name;
    static String sex;

    void test() {
        //test1();
        //System.out.println(sex);
        System.out.println("test...");
    }
    static void test1() {
       // test();
        //System.out.println(name);
        //System.out.println("test1...");
    }
}
class Bird1 {
    static String type = "鸟";
    static void fly() {
        System.out.println("飞...");
    }
}

静态代码块

static { xxx }

类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化（按照声明静态代码块顺序依次执行）

对象准备创建时（对象创建前），也会自动调用代码块 {xxx}，但不是静态的

类加载，调用静态代码块=》创建对象：调用代码块（创建对象时已经加载类了）

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

        // TODO 面向对象 - 静态

        // 类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能
        // 对象准备创建时，也会自动调用代码块，但不是静态的
        //User08.test();
        new User08();
    }
}
class User08 {
    static {
        // 静态代码块
        System.out.println("静态代码块执行1");
    }
    static {
        // 静态代码块
        System.out.println("静态代码块执行2");
    }
    static void test() {
        System.out.println("test...");
    }
    {
        System.out.println("代码块执行1");
    }
    static {
        // 静态代码块
        System.out.println("静态代码块执行3");
    }
    {
        System.out.println("代码块执行2");
    }
}

包：

包主要用于分类管理
package + 包路径（用 . 隔开）
一个类可以没有包，但不能使用多次
为了区分类名，一般都是小写

如：java（包）.lang（包）.Object（类）

Java 中存在不同包的相同名称的类，可以写类的全名加以区分（包名 + 类名）

import

JVM 会在使用时自动添加 java.lang 包
可以使用 import 在使用类前导入包（位于 package 后，class 前），可以多次使用
如果 import 了不同包中相同名称的类，如 Date，使用时最好还是增加包名

import java.util.*;
import java.sql.Date;
public class Java10_Object_Import {
    public static void main(String[] args) {

        // TODO 面向对象 - import
        // import 主要用于在使用类前准备好了。
        // import语句只能使用在package后，class前。
        // import关键字可以多次使用，导入多个类
        // 如果同一个包中需要导入大量的类，那么可以使用通配符星号来简化操作。
        // 如果import了不同保重相同名称的类，那么还是需要在使用时增加包名。
        // chapter04.Java10_Object_Import
        String name = "zhangsan";
        String name1 = "zhangsan";

        java.util.Date d = new java.util.Date();
        new ArrayList();

        new Java10_Object_Import();
        new Java10_Object_Import();
        new User10();

    }
}
class User10 {

}