0


深入理解类和对象(2) —— Java SE

                  ![](https://img-blog.csdnimg.cn/c676d80f9561491191588c5a77e61735.jpeg)![](https://img-blog.csdnimg.cn/7c80bed636bd447ca5b7ed4c0b905921.jpeg)

🐲 1. static 成员

🦄 1.1 static的作用

先定义一个学生类

public class Student {
    public String name;
    public String gender;
    public int age;
    public double score;

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
    public void PrintStudent(){
        System.out.println(name + " " + gender + " " + age + " " + score);
    }

    public static void main(String[] args) {
        Student s1 = new Student("Zhang san","男",20,4.0);
        Student s2 = new Student("li si","男",21,3.9);
        Student s3 = new Student("Wing wu","男",22,2.9);
        s1.PrintStudent();
        s2.PrintStudent();
        s3.PrintStudent();
    }
}

🟦****在Student类中定义的成员变量,每个对象中都会包含一份实例变量 ,也就是用来描述三个学生

🟪****假如说这三个学生是一个班的,再来一个成员变量,用来表示这个班级,然后将这个成员变量对所有学生共享。

这就要用到,static来修饰成员变量了,

🟧被static修饰的成员叫静态成员,或者叫类成员,它对所有对象是共享的。

🦄** 1.2 static修饰成员变量**

🟥static 修饰的成员变量,叫做静态成员变量。

🟦作用是 这个静态成员变量是所有对象共享的,不是属于单独某个具体对象。

访问有两种方式

⚜️第一种 通过对象访问(不建议),

因为静态成员变量是所有对象共享的

** ⚜️第二种 直接通过类名来访问(建议使用这种)**

好了,就是上面两种方法可以访问静态成员变量 ,

⚜️需要额外注意的两点是:

** (1)类变量存储在方法区中**

** (2)生命周期同类一样**

下面看一下全部代码

public class Student {
    //普通成员变量
    public String name;
    public String gender;
    public int age;
    public double score;
    //静态成员变量,不属于对象
    //被Static修饰就变成了静态成员,都可以使用这个,变成共享的
    public static String classRoom = "gao yi 13 ban";

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
    public void PrintStudent(){
        System.out.println(name + " " + gender + " " + age + " " + score);
    }

    public static void main1(String[] args) {
        //静态成员可以直接使用类名来访问
        Student s1 = new Student("Zhang san","男",20,4.0);
        Student s2 = new Student("li si","男",21,3.9);
        Student s3 = new Student("Wing wu","男",22,2.9);
        //不建议通过对象的引用去访问
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
        //建议最好通过类名去访问
        System.out.println(Student.classRoom);
        //只是通过类名点出来的
        s1.PrintStudent();
        s2.PrintStudent();
        s3.PrintStudent();
    }
}

🦄 1.3 static修饰成员方法

🟥static修饰成员方法,叫做静态成员方法,

🟦 静态成员方法是类的方法,不是某个对象所特有的,

** 静态成员一般是通过静态方法来访问**

⚜️那么如何访问静态方法呢

** 因为静态方法是类方法,所以可以直接访问**

class Student {
    public String name;
    public double score;
    public int age;
    public static  String classRoom = "gao yi 13 ban" ;

    public Student(String name, double score, int age) {
        this.name = name;
        this.score = score;
        this.age = age;
    }

    public static void staticFunc(Student student) {
        System.out.println("这是一个静态的方法!也是类方法");
    }
}
public class Test01 {
    public static void main(String[] args) {
        Student.staticFunc();
    }
}

⚜️先思考一下,如何在静态方法中,访问非静态的成员变量

首先,因为静态方法不需要对象,所以直接访问在静态方法访问非静态的成员变量,是不可行的。

其次,如果必须要访问,我们应该考虑的是,如何通过对象调用,使静态方法中,可以访问非静态的成员变量

有两种方法:

**🟥第一种,既然要访问非静态成员变量,而静态方法又不需要对象,那么给静态方法中调用对象,不就可以了 **

🟪 第二种,也可以给静态方法个参数(建议使用这种)

⚜️再思考最后一个问题,静态方法中,可以调用非静态的方法吗?

🟪不可以直接调用,因为非静态方法有this参数,(this表示当前对象的引用)在静态方法中调用时候无法传递this引用

总结一下,

🟥静态方法是类方法,不属于某个具体的对象

🟧静态方法中,不能直接访问非静态的变量,

🟦静态方法中,也不能调用非静态的方法


🐲 2.代码块

使用{ }定义的一段代码叫代码块,根据代码块定义的位置和关键字,分为了4种

普通代码块,构造代码块,静态代码块,同步代码块,我们这里先讲解前3个代码块

🦄2.1 普通代码块

🟪定义在方法中的代码块,叫普通代码块

    public static void main(String[] args) {
        {
            //1.普通代码块,直接用{}定义
            int x = 10;
            System.out.println("x1="+x);
        }
        int x = 100;
        System.out.println("x2="+x);
    }

🦄2.2 实例代码块(构造代码块)

🟪定义在类中的代码块(前面没有修饰符)

🟦用于初始化实例成员变量

class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    public Student(){
        System.out.println("I am Student!");
    }
     //实例代码块
    {
        this.name = "zhang san";
        this.age = 24;
        this.score = 45.6;
        System.out.println("I am Instance!");
    }
    public void Show(){
        System.out.println("name" + name + "age" + age + "score" + score);
    }
}
public class Test01 {
public static void main(String[] args) {
    //2.构造代码块:定义在类中的代码块,也叫实例代码块
    //一般用于初始化实例成员变量
    Student  student = new Student();
    student.Show();
}

}

🦄2.3 静态代码块

🟪使用static定义的代码块

🟩用于初始化静态成员变量

class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    static {
        classRoom = "gao er 13 ban ";
        System.out.println("I am static");
    }
    public Student(){
        System.out.println("I am Student!");
    }
}
public class Test01 {
public static void main(String[] args) {
    //3.静态代码块:用于初始化静态成员变量
    Student s1 = new Student();
    Student s2 = new Student();
}
}

注意:

🟥(1)静态代码块不管生成有多少个对象,只会执行一次

🟧(2)静态成员变量是类的属性,因此是在JVM加载类是开辟空间进行初始化

🟦(3)实例代码块只有在创建对象时才会执行

⚜️下面思考一个问题,

⚜️如果一个类中,有构造方法,实例代码块,静态代码块****,执行的顺序是怎么样的

先执行静态代码块(如果有多个静态代码块,看定义顺序执行)(静态代码块只会执行一次),再执行实例代码块,最后执行构造方法


🐲 3. 理解内部类

如果内部类的完整结构只为外部事物提供服务,那么这个内部的完整结构最好使用内部类。

🟪将一个类定义在另一个类或者一个方法的内部,

🟥比如 InnerClass{}就是内部类,OuterClass{}就是外部类。

🟩内部类和外部类共用一个java源文件,经过编译后,内部类会形成单独的字节码文件

**🦄 **3.1 内部类的分类

在外部类中,内部类定义位置与外部类成员所处的位置相同,所以也叫做成员内部类

实例内部类 静态内部类 (本篇先介绍前两个)

**本地内部类 匿名内部类 **

🦄 3.2 实例内部类

⚜️****实例内部类就是没有static修饰的成员内部类

下面看这个例子 ,可以很清楚的看到实例内部类

class  OuterClass{

    public int date1 = 1;
    private int date2 = 2;
    public static int data3 = 3;
    //实例内部类,没有别static修饰
    class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static final int data3 = 6;

        public InnerClass(){
            System.out.println("实例内部类的构造方法!");
        }
        public void innerFunc(){
            System.out.println("实例内部类的普通方法!");
            System.out.println(date1);
            System.out.println(date2);
            System.out.println(data3);
        }
    }
}
public class Test01 {
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        OuterClass.InnerClass innerClass = out.new InnerClass();
        innerClass.innerFunc();
    }
}

通过上面代码,可以清楚知道

🟪在实例内部类中可以直接访问外部类中:任意访问限定符修饰的成员

⚜️ 1.下面思考一下,如果外部类和实例内部类具有相同名称的成员时,先访问谁,

** 并且如果要访问外部类同名成员时,如何访问?**

** 那如果是同名的静态成员呢,如何访问?**

🟦同名时,优先访问的是内部类自己的,

🟧要访问外部类同名成员时,按这样格式访问

外部类名称.this.同名成员名字

🟪外部类类名.同名成员名字

⚜️** 2.实例内部类中,不能直接定义静态的成员变量,如果必须要定义,如何做?**

** 实例内部类中,可以定义静态方法吗?**

🟪****如果必须要定义,那么这个静态变量成员就应该被final所修饰

** 不可以,定义静态方法**

⚜️ 3.如何实例化,实例内部类

有两种方法:

🟦外部类类名.内部类 变量=外部类引用,new 内部类();

*🟩***外部类类名.内部类 变量=new 外部类().new 内部类(); **


🦄3.3 静态内部类

**🟪被static修饰的内部成员类称为静态内部类。 **

下面看这个例子 ,可以很清楚的看到静态内部类

class OuterClass1{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    static class InnerClass{
        public int data4 =4;
        private int data5= 5;
        public static int data6 =6;

        public InnerClass(){
            System.out.println("静态内部类的构造方法!");
        }
        public void test(){
            System.out.println("test方法执行了!");
    
            System.out.println(data4);
            System.out.println(data3);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}
public class Test02 {
    public static void main(String[] args) {
        OuterClass1.InnerClass innerClass = new OuterClass1.InnerClass();
        innerClass.test();
    }
}

通过上面代码,可以清楚知道

🟧**1. 在静态内部类中只能访问外部类中的静态成员 **

🟪**2. 创建静态内部类对象时,不需要先创建外部类对象 **

⚜️ 1.下面思考一下,如何拿到静态内部类中的对象

🟩外部类类名.内部类类名 变量 = new 外部类类名.内部类类名。

⚜️ 2.不能在静态内部类当中,直接访问外部类非静态的数据成员,那么怎么样才能访问到外部类非静态的数据成员?

有两种方法,都是靠对象来引用的

🟪第一种直接在内部类当中引用对象

🟧 第二种 通过参数引用


🦄 3.4 本地内部类

定义在外部类的方法体或者{}中,本地内部类只能在其定义的位置使用,这里简单了解一下

public class Test03 {
    public static void func() {
        class A{
            public void test(){
                System.out.println(100);
            }
        }
        A a = new A();
        a.test();
    }
    public static void main(String[] args) {
        func();
    }
}

🟧只能在该方法体内部使用,其他位置都不能用


🐲 4.打印对象

public class Test03 {
class Person{
        public String name;
        public int age;
    
    @Override//注解:注释【代表这个方法是重写父类的】+解释
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test03{
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}

以后重写toSring可以借助IDea功能来快速写出


标签: java 开发语言

本文转载自: https://blog.csdn.net/m0_58761900/article/details/124766969
版权归原作者 快到锅里来呀 所有, 如有侵权,请联系我们删除。

“深入理解类和对象(2) —— Java SE”的评论:

还没有评论