【Java SE】(七)类和对象(2)

文章目录

• 前言
• 一、static修饰
• • 1.1 static修饰成员变量
  • 1.2 static修饰成员方法
  • 1.3 static成员变量初始化
• 二、代码块
• • 2.1 代码块的概念和分类
  • 2.2 普通代码块
  • 2.3 构造代码块
  • 2.4 静态代码块
• 三 内部类
• • 3.1 内部类的分类
  • 3.2 普通内部类
  • 3.3 静态内部类
• 四 打印对象
• 总结

---

前言

上一次我们学到了类和对象的上半部分，介绍了怎么定义一个类，类的实例化，类的初始化以及this引用和构造方法等，但是在类和对象中还存在着许多的知识点，比如用什么来修饰一个类的成员变量和类的成员方法等，接下来就开始我们类和对象的下半部分！

---

一、static修饰

在Java中被static修饰的成员(类成员)，其中它不属于任何具体的对象，是所有对象共享的。

1.1 static修饰成员变量

static修饰的成员变量，称为静态成员变量；
特征：

1.不属于任何具体对象，是类的属性，是所有对象的共享的，不存储于任某个空间中；
2.可以通过对象/类名访问，更推荐类名访问；
3.类变量存储在方法区中；
4.生命周期伴随类的一生。

public class Student{
       public String name;
       public int age;
       public String sex;
       public double scorce ;
       public static String classroom = "14班";
       public static void main(String[] args) {
              System.out.println(Student.classroom) //通过类名访问
              Student student1 = new Student("lucky","女",20,5.0,);
              System.out.println(student1.classroom) // 通过对象访问

    }
}

通过以上这段代码的编译我们可以知道，静态成员变量并没有被存储到某个具体对象当中

1.2 static修饰成员方法

static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象特有的，静态成员一般都是通过静态方法来访问的。

public class Student{
    public static String classroom = "14班"; // 静态成员变量通过静态方法类访问
    public static String getclassroom(){  // 静态方法
        reture classroom;
    }
public class TestDemo{
    public static void main(String[] args) {
      System.out.println(Student.classroom);     
    }
}

静态方法特性
1.不属于某个对象，是类方法；
2.可以通过引用或者类名.静态方法名调用；
3.静态方法中没有隐藏的引用参数this，因此在静态方法中不能访问任何非静态成员变量，

public static String getClassroom(){
    System.out.println(this);// 编译失败，无法引用非静态变量this
    reture Classroom;   
    
public static String getClassroom(){
    scorce += 12;  // 静态成员方法中无法引用非静态变量age
    reture Classroom;

4.静态方法中不能调用任何其他的非静态方法，因为非静态方法有引用参数this，使用静态方法调用时无法传递this引用

public static String getClassroom(){
     dohomework(); //非静态方法
     return classroom;
}

5.静态方法无法重写

1.3 static成员变量初始化

静态成员初始化分为两种：就地初始化和静态代码块初始化。
就地初始化：定义是直接给出初始值。

public class Student{
   public static String name  = "lucky";
   public static int age = 18;
   public static String sex = "女";
   public static double scorce  = 4.9;
   public static String classroom = "14班";
   public static String classroom = "14班";

我们说静态成员变量初始化有就地初始化和静态代码块初始化，这时候我们就什么是代码块呢？下面我们展开来讲

二、代码块 2.1 代码块的概念和分类

使用{ }定义的一段代码称为代码块，根据代码块的位置以及关键字，代码块分为以下四种
1.普通代码块
2.构造块
3.静态块
4.同步代码块
这里我们先将前三种代码块。

2.2 普通代码块

定义在方法中的代码块

public class fun{
    public static void main(String[] args){
        int a = 3;
        System.out.println(a);
    }
}

2.3 构造代码块

定义在类中的代码块(示例代码块),用于初始化实例成员变量。

public class Student{
  // 实例成员变量
   public String name;
   public int age;
   public String sex;
   public double scorce;
   public String classroom ;
   public Student(){
       System.out.println("hello")
   }
   //示例代码块
   {
       this.name = "lucky";
       this.age = 19;
       this.sex = "女";
       this.scorce = 3.9;
       System.out.println("hello")
   }
   // 构造方法
   public void show(){ 
       System.out.println("姓名"+neme+"年龄"+age+"性别"+sex+"绩点"+scorce);
   }
public class TestDemo{
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }
}

注意：实例代码块优先于构造方法执行，编译完成后，编译器会将实例代码块中的内容拷贝到每一个构造方法第一条语句前。

2.4 静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{
  // 实例成员变量
   public String name;
   public int age;
   public String sex;
   public double scorce;
   public String classroom ;
   //示例代码块
   {
       this.name = "lucky";
       this.age = 19;
       this.sex = "女";
       this.scorce = 3.9;
       System.out.println("hello")
   }
   // 静态代码块
 static{
   classroom = "104班";
   System.out.println("我是104班的学生");
}
//构造方法
public Student(){
   System.out.println("我是104班的学生");
}
public class TestDemo{
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
   

注意：
静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此实在JVM加载类十开闭空间并初始化的。

三 内部类

Java中，可以将一个类定义在另一个类中或者一个方法，前面那个类称作内部类，后面这个称为外部类。

public class outClass{ // 这是外部类
class innerClass{ // 这是内部类
}
}
注意：
1定义在calss 类名{ } 花括号外部的，不是成为内部类。
public class nowClass{

}
class otherClass{

}
这是两个不同的类
2.内部类和外部类共用一个Java源文件,但是经过编译之后,内部类会形成单独的字节码文件.

3.1 内部类的分类

内部类按照可以放在类的那些位置上进行定义分类

public class Outclass{
     public class InnerClass{  // 没有被static修饰——》普通内部类
   }
}
static public class Outclass1{ // 被static修饰——》静态内部类
     
}

public void method(){
    class InnerClass1{  //定义在方法中——》局部内部类(匿名内部类)
    
    }
}

3.2 普通内部类

public class funclass{
    privrte int a;
    static int i;
    int d;
    public void methorFrist(){
        System,out,println(a);
}
public void methorScoed(){
        System,out,println(i);
}
 public class funclass1{ // 未被static修饰——》普通内部类
      **// 在内部类中可以直接访问外部类中，任意访问限定符修饰的成**员
      a = 12;
      i = 23;
      methoFrist();
      methonScoed();  
       
      d = 18; // 如果外部类和内部类中具有相同名称成员时，优先访问的是内部类自己的
      System.out.println(d);
      fun1class.this.d = 23;  //若想访问外部类同名称成员时，必须用this.同名称成员
       
}
}

注意：
1.怎么创建外部类的对象和访问其成员呢？
通过 外部类名 创建的对象名 = new 外部类名(）——》创建对象
通过 创建的对象名.外部类中的成员变量 和 方法——》访问成员和方法
2.若想访问普通内部类中成员，必须创建普通内部类的对象
3.当外部类和内部类的成员变量定义位置相同时，创建内部类的对象前必须要借助外部类,且也受访问限定符的限制
例如
外部类名.内部类名 = new 外部类名().内部类名();

3.3 静态内部类

静态内部类就是被static修饰的类

public class test {
    public int a;
    static int g;
    public void fun(){
        int b;
    }
    static void fum2(){
        int g;
    }
    static class Fun{
        public static void mothon(){
            b = 3; // 静态内部类只能访问外部类中的静态成员
            g = 3;
            fun(); // 同理，静态内部类中只能访问外部类中的静态方法
            fum2();
            
        }
        public static void main(String[] args) {
          Fun fun1 = new Fun();
          fun1.mothon(); //创建静态内部类对象不需要创建外部内对象
    }
    }

内部类，经过编译后会生成独立的字节码文件，命名格式：外部类名$x内部类名.class，x为一个整数。

四 打印对象

public class test {
    public int age;
    String name;

    public test(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {  //重写toString方法，可以打印出创建对象里的内容，若是没有重下，则打印出的是地址
        return "test{" +
                "age=" + age +
                ", name='" + name + ''' +
                '}';
    }

    public static void main(String[] args) {
        test person = new test(18,"lili");
        System.out.println(person);
    }

总结

本章是对类和对象的介绍，我们了解到类和对象的关系，还有如何去创建一个类和对象，以及类的分类和一些注意事项，由于能力有限，若有不足之处，还望指正。