类的成员

对Java中类的成员，属性、方法、构造器、代码块、内部类的简要介绍

Author: Msuenb

Date: 2023-02-08

属性

  • 语法格式

    【修饰符】 数据类型 属性名 = 初始化值

    修饰符有：private、缺省、protected、public、static、final...

  • 示例

    public class Person {
    private String name = "Tom";
    private int age;
}

成员变量与局部变量

  • 声明在类体内，方法体外的变量称为成员变量。

  • 声明在方法体内部的变量称为局部变量。

    • 成员变量：在方法体外，类体内声明的变量
      • 实例变量（不以static修饰）
      • 类变量（以static修饰）
    • 局部变量：在方法体外声明的变量
      • 方法局部变量（在方法内定义）
      • 代码块局部变量（在代码块内定义）
      • 形参（方法、构造器中定义的变量）

成员变量（属性）与局部变量的区别

成员变量 局部变量
声明的位置 直接声明在类中 方法形参或内部、代码块内、构造器内
修饰符 private、public、final... 不能用权限修饰符和static，只可以用final修饰
初始化值 有默认初始化值 没有默认初始化值，必须显式赋值
作用域 整个类中 函数/代码块/内部类 内部
生命周期 和类/对象生命周期一样 和方法调用生命周期一样
内存加载位置 堆空间 或 静态域内（静态变量） 栈空间

说明：

  1. 声明的位置

    public class Person {
    String name = "Tom";	// 成员变量
    int age = 18;		// 成员变量
    						
    public void show(String loc) {  // loc 局部变量
        String subject = "大数据";	// 局部变量
    }
}

  2. 修饰符

    public class Person {
    public String name = "Tom";	// public 修饰
    private int age = 18;		// private 修饰
    
    public static final double PI = 3.14;	// 组合使用
    						
    public void show(String loc) {  
       //publilc String subject = "大数据";	// 错误
        
       //static int a = 3;	// 错误
        
       final int b = 4;	//正确
    }
}

  3. 初始化值

    class Person {
    String name;	// 成员变量
    int age;		// 成员变量

    public void show(String loc) {  // loc 局部变量
        String subject;	// 局部变量

        //System.out.println(subject);	// 编译错误 subject未初始化 须显式赋值
    }
}

public class Test {				
    public static void main(String[] args) {
        Person p = new Person();
        p.show("上海");

        System.out.println(p.name); // null
        System.out.println(p.age);  // 0
    }
}

    成员变量的默认初始化值

    分类 数据类型 默认值
    基本类型 整数（byte，short，int，long） 0
    浮点数（float，double） 0.0
    字符（char） '\u0000'
    布尔（boolean） false
    数据类型 默认值
    引用类型 数组，类，接口 null

  4. 生命周期

    • 成员变量：静态变量的生命周期和类的一样。实例变量的生命周期和对象一样，随着对象创建而存在，随着对象被GC回收而消亡。
    • 局部变量：和方法调用的生命周期一样，随着方法被调用而存在，方法执行结束而消亡。

  5. 内存加载位置

    class Person {
    private String name = "Tom";
    private int age = 18;
    						
    public void show(String loc) {  // loc 局部变量
        String subject = "大数据";	// 局部变量
    }
}

public class Test {				
    public static void main(String[] args) {
        Person p = new Person();	
        p.show("上海");
    }
}

    成员变量和局部变量在内存中的位置

    pS2y3es.png

    说明：在方法中声明的变量可以是基本数据类型的变量，也可以是引用数据类型的变量。

    • 当声明的是基本数据类型的变量时，其变量名和值都放在虚拟机栈中。
    • 当声明的时引用数据类型的变量时，虚拟机栈中存放的是变量名和地址值，该变量所指的对象是存放在堆内存中的。

    类变量（静态变量）会被加载到JVM内存中方法区（静态域）中，详见：final_static关键字的使用说明

方法

方法也叫函数，是一组代码语句的封装，用来完成某个功能操作。方法能够实现代码重用，减少代码冗余。方法不能独立存在，必须定义在类中方法外。

方法的声明和调用

  • 语法格式

    【修饰符】返回值类型 方法名(【参数类型 形参1, 参数类型 形参2...】) 【throws 异常列表】 {
    方法体代码
}

    修饰符有：public、缺省、private、protected

    返回值类型：

    • 没有返回值：void
    • 有返回值：声明返回值的类型，如int、String...

    注意：

    一般情况下，方法中的多个return语句只会执行一个。

    特殊情况（finally语句）下，方法中的多个return语句会被执行多个。

  • 正确示例

    class MethodDefineDemo {
  	// 无参无返回值方法的演示
    void sayHello(){
        System.out.println("hello");
    }

    // 有参无返回值方法的演示
    void printRectangle(int length, int width, char sign){
        for (int i = 1; i <= length ; i++) {
            for(int j=1; j <= width; j++){
                System.out.print(sign);
            }
            System.out.println();
        }
    }

    // 无参有返回值方法的演示
    int getIntBetweenOneToHundred(){
        return (int)(Math.random()*100+1);
    }
    
   	// 有参有返回值方法的演示
    int max(int a, int b){
        return a > b ? a : b;
    }
}

    错误示例

    类{
    方法1(){
        方法2(){  //位置错误
        
       }
    }
}

  • 方法调用

    对象.方法名(【实参1, 实参2...】);

  • 示例

    public class MethodInvokeDemo {
    public static void main(String[] args) {
        //创建对象
        MethodDefineDemo md = new MethodDefineDemo();

        //调用MethodDefineDemo类中无参无返回值的方法sayHello
        md.sayHello();
        md.sayHello();
        //调用一次，执行一次，不调用不执行

        //调用MethodDefineDemo类中有参无返回值的方法printRectangle
        md.printRectangle(5,10,'@');

        //调用MethodDefineDemo类中无参有返回值的方法getIntBetweenOneToHundred
        md.getIntBetweenOneToHundred();//语法没问题，就是结果丢失

        int num = md.getIntBetweenOneToHundred();
        System.out.println("num = " + num);

        //调用MethodDefineDemo类中有参有返回值的方法max
        int bigger = md.max(5,6);
        System.out.println("bigger = " + bigger);
    }
}

  • 可变形参说明

    JavaSE 5.0 中提供了 Varargs 机制，允许直接定义能和多个实参相匹配的形参。

    • 声明格式

      方法名(参数类型名... 参数名){}

    • 示例

      public static void test(int... nums) {}

    注意事项

    1. 方法内部有可变形参，需要放在形参声明的最后。

      public static void test(int... nums, String str) {} 错误

    2. 在一个方法的形参位置，最多只能有一个可变形参

      public static void test(int... nums, String... strs) {} 错误

    3. 可变参数的本质就是数组，注意重载的问题

方法参数传递机制

  • 形参：方法声明时的参数
  • 实参：方法调用时实际传给形参的参数值

Java 里方法的参数传递方式只有一种：值传递。即将实际参数值的副本传入方法内，而参数本身不受影响。

  • 形参是基本数据类型：将实参的 "数据值" 传递给形参 。形参值的改变不影响实参。
  • 形参是引用数据类型：将实参的 "地址值" 传递给形参。形参地址值的改变不影响实参，但是形参地址值指向的数据的改变会影响实参。

  1. 形参是基本数据类型

    package com.atguigu.test05.param;

public class PrimitiveTypeParam {
    void swap(int a, int b){//交换两个形参的值
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        PrimitiveTypeParam tools = new PrimitiveTypeParam();
        int x = 1;
        int y = 2;
        System.out.println("交换之前：x = " + x +",y = " + y);//1,2
        tools.swap(x,y);//实参x,y是基本数据类型，给形参的是数据的“副本”，调用完之后，x与y的值不变
        System.out.println("交换之后：x = " + x +",y = " + y);//1,2
    }
}

  2. 形参是引用数据类型

    public class ReferenceTypeParam {
    void swap(MyData my){//形参my是引用数据类型，接收的是对象的地址值，形参my和实参data指向同一个对象
        //里面交换了对象的两个实例变量的值
        int temp = my.x;
        my.x = my.y;
        my.y = temp;
    }
    
    void change(MyData my) {
        my = null;
    }

    public static void main(String[] args) {
        ReferenceTypeParam tools = new ReferenceTypeParam();
        MyData data = new MyData();
        data.x = 1;
        data.y = 2;
        System.out.println("交换之前：x = " + data.x +",y = " + data.y);//1,2
        tools.swap(data);//实参是data，给形参my的是对象的地址值，调用完之后，x与y的值交换
        System.out.println("交换之后：x = " + data.x +",y = " + data.y);//2,1

        tools.change(my);
        System.out.println("修改之后：x = " + data.x +",y = " + data.y);//2,1 没有改变
    }

}

    public class MyData{
    int x;
    int y;
}

方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。

详见：方法重载与重写

构造器

构造器又叫构造方法，用来创建对象，并在创建对象的时候为实例变量赋初值。

构造器声明和使用

  • 构造器语法格式

    【修饰符】 class 类名{
    【修饰符】 构造器名() {
        // 实例初始化代码
    }
    
    【修饰符】 构造器名(参数列表) {
        // 实例初始化代码
    }
}

    注意事项：

    1. 构造器名必须与它所在的类名必须相同。
    2. 它没有返回值，所以不需要返回值类型，甚至不需要void
    3. 如果你不提供构造器，系统会默认给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
    4. 如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
    5. 构造器是可以重载的，既可以定义参数，也可以不定义参数。
    6. 构造器的修饰符只能是权限修饰符(public、protected、缺省、private都可以)，不能被其他任何修饰

  • 示例

    public class Student {
    private String name;
    private int age;
   
    public Student() {}   // 无参构造

    // 构造器重载
    public Student(String name,int age) {  // 有参构造
        this.name = name;
        this.age = age;
    }
}

  • 使用new创建对象

    public class TestStudent {
    public static void main(String[] args) {
        
        Student s1 = new Student();	//调用无参构造创建学生对象
        Student s2 = new Student("张三",23); //调用有参构造创建学生对象
    }
}

在其他构造器调用构造器

在同一个类中可以使用this关键字调用本类的构造器；子类继承父类时，可以使用super关键字调用父类中的构造器。

详见：this与super的使用

代码块

代码块（或初始化块）的主要作用是，对 Java 类和对象进行初始化。详见：代码块的使用细节

内部类

在 Java 中，允许在一个类的内部定义另一个类，前者称为外部类，后者称为内部类。

详见：Java 的四种内部类

posted @ 2023-02-12 18:34  msuenb  阅读(43)  评论(0)  编辑  收藏  举报