JavaSE---类和对象（下）

最新推荐文章于 2024-08-26 16:40:46 发布
最新推荐文章于 2024-08-26 16:40:46 发布
阅读量682 收藏 13
点赞数 12
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joker10085/article/details/139633355
版权

 7. static成员

7.1 再谈学生类

使用前文中介绍的学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成 员信息，这些信息就是对不同学生来进行描述的，如下所示：

使用前文中介绍的学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成 员信息，这些信息就是对不同学生来进行描述的，如下所示：  

public class Student{
    public String name;
    public String name;
    public short  age;
    public double score;
    public Student(String name,String name,short age,double score){
  this.name=name;
  this.name=name;
  this.age=age;
  this.score=score;
}
    public void DoClass(){}
    public void DoHomework(){}
    public void Exam(){}
public static void main(String[] args) {
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);

}
}

假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成 员变量，来保存同学上课时的教室呢？答案是不行的。

之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。  

7.2 static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student{
    public String name;
    public String gender;
    public int  age;
    public double score;
    public static String classRoom = "Bit306";
    
    // ...
    
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
 
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
 
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
}
}

 

 7.3 static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom = "Bit306";
    
    // ...
}
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.classRoom);
   }
}
 
编译失败：
Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制

那static属性应该如何访问呢？

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

public class Student{
    // ...
    
    private static String classRoom = "Bit306";
    
    // ...
    
    public static String getClassRoom(){
        return classRoom;
   }
}
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
   }
}
输出：Bit306

 【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

public static String getClassRoom(){
    System.out.println(this);
    return classRoom;
}
 
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
 
public static String getClassRoom(){
    age += 1;
    return classRoom;
}
 
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

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

public static String getClassRoom(){
    doClass();
    return classRoom;
}
 
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

7.4 static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。

1. 就地初始化

就地初始化指的是：在定义时直接给出初始值

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom = "Bit306";  
    
    // ...
}
 2. 静态代码块初始化

那什么是代码块呢？继续往后看

8. 代码块

8.1 代码块概念以及分类

使用 {} 定义的一段代码称为代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块

构造块

静态块

同步代码块（多线程部分）

8.2 普通代码块

普通代码块：

定义在方法中的代码块.

public class Main{
 public static void main(String[] args) {
 { //直接使用{}定义，普通方法块
 int x = 10 ;
 System.out.println("x1 = " +x);
 }
 int x = 100 ;
 System.out.println("x2 = " +x);
 }
}
 
// 执行结果
x1 = 10
x2 = 100

这种用法较少见 

8.3 构造代码块

构造块：定义在类中的代码块(不加修饰符)。

也叫：实例代码块。

构造代码块一般用于初始化实例成员变量。

public class Student{
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

8.4 静态代码块

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

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
// 静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}

注意事项

静态代码块不管生成多少个对象，其只会执行一次

静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

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

9. 内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么这个内部的完整结构最好使用内部类。在Java 中，可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类。内部类也是封装的一种体现。 

public class OutClass {
    class InnerClass{
 
   }
}
 
// OutClass是外部类
// InnerClass是内部类

【注意事项】

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类 

public class A{
    
}
 
class B{
    
}
 
// A 和 B是两个独立的类，彼此之前没有关系

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

9.1 内部类的分类

先来看下，内部类都可以在一个类的那些位置进行定义  

public class OutClass {
    // 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{
   }
 
    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
 
   }
 
 
    public void method(){
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{
 
       }
   }
}

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未被static修饰的成员内部类，静态内部类：被static修饰的成员内部类)

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

2. 局部内部类(不谈修饰符)、匿名内部类 注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类。

9.1.1 实例内部类

即未被static修饰的成员内部类。

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
   }
 
    public static void methodB(){
        System.out.println(b);
   }
 
    // 实例内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){
            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b =200;
            methodA();
            methodB();
 
            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
 
            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
       }
   }
 
    public static void main(String[] args) {
        // 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
 
        System.out.println("=============实例内部类的访问=============");
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
 
        // 创建实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
 
        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
   }
}

【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名 称.this.同名成员来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

9.1.2 静态内部类

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

public class OutClass {
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
   }
 
    public static void methodB(){
        System.out.println(b);
   }
 
    // 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            // a = 100;     // 编译失败，因为a不是类成员变量
            b =200;
            // methodA();   // 编译失败，因为methodB()不是类成员方法
            methodB();
       }
   }
 
    public static void main(String[] args) {
        // 静态内部类对象创建 & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
   }
}

 【注意事项】

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

如果确实想访问，我们该如何做？

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

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

4. 几乎不会使用

10. 对象的打印

public class Person {
    String name;
    String gender;
    int age;
 
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
}
 
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
   }
}// 打印结果：day20210829.Person@1b6d3586

如果想要默认打印对象中的属性该如何处理呢？

答案：重写toString方法即可。 

public class Person {
    String name;
    String gender;
    int age;
 
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
   }
 
    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
   }
 
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
   }
}
 
// 输出结果：[Jim,男,18]

Joker10085
关注
  • 12
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JavaSE-面向对象之类与对象
qq_59737375的博客
04-22 2126
权限控制符] class 类名 {//零个到多个构造器 * 构造器定义 * 注意:构造器无返回值类型[权限控制符] 类名(参数列表){};//零个到多个属性 * 属性定义[权限控制符] [static | final] 属性类型 属性名;//零个到多个方法 * 方法定义[权限控制符] [abstract | final] [static] 返回值类型 方法名(参数表){};提示：定义类的时候，不是必须显式写构造方法、属性、方法。【示例】：定义一个学生类。
JavaSE--抽象类和接口
2302_81017910的博客
05-18 692
Object类中的hashCode()方法的默认实现是根据对象的内存地址计算得出的，因此不同对象的哈希码一般是不相同的。由于所有的类都继承自Object类，因此可以在任何类的实例上调用Object类的方法。内部类是指在一个类的内部定义的另一个类。接口的继承可以使得一个接口继承另一个接口的方法和常量，通过继承，子接口可以拥有父接口中定义的所有方法和常量，同时可以定义自己的方法和常量。内部类的使用可以提高代码的灵活性和封装性，特别是在某个类只在一个类中使用时，可以将其定义为内部类，减少类的数量和代码的复杂性。
JavaSE - 集合类-工具类
adas5f1a51的博客
11-20 7014
JavaSE - 集合类-工具类 本节学习目标： 了解和掌握迭代器的使用方法； 了解和掌握比较器的使用方法； 了解和掌握选择器的使用方法； 了解和掌握Collections工具类中的常用方法。 1. 集合工具接口 Java对集合框架提供了很多工具接口，我们可以实现或使用这些接口来对集合进行修改与定制化。 1.1 迭代器 1. Iterable 接口 Iterable接口位于java.lang包下，意为可遍历的。 Collection接口继承了Iterable接口，所以Collection集合是可以使用迭
JavaSE--类与对象
ks_xfx的博客
04-24 482
​ 这里写目录标题类和对象1、面向对象1.1、什么是面向对象？1.2、面向过程和面向对象2、类的定义和使用2.1、简单定义类2.2、类的定义格式2.3、小练习3、类的实体化3.1、什么是实例化4、this的引用4.1、什么是this引用4.2、this引用的特性5、对象的构造及初始化5.1、如何初始化对象5.11就地初始化5.2、构造方法5.21、概念5.22、特性5.3、默认初始化6、封装6.1、封装的概念6.2、限定访问符 类和对象 1、面向对象 1.1、什么是面向对象？ 在面向对象的世界里，一切皆为对
Java---类和对象
qq_34274797的博客
11-27 397
Java中类与对象的简单介绍
javase-3.3.0.zip
08-29
3. 创建二维码数据矩阵：使用工具包提供的类和方法，生成包含特定信息的二维码数据矩阵。这通常涉及到创建一个`BitMatrix`对象，然后填充数据。 4. 调用`writeToPath()`方法：一旦有了数据矩阵，就可以调用`...
JavaSE--思维导图解析
07-26
+ 修饰类，标识该类不能被继承 类型转换 * 强制类型转换 * 隐式类型转换 * 类型提升 运算符 * 位运算： + 逻辑与 `&` + 逻辑或 `|` + 按位异或 `^` + 按位取反 `~` * 移位运算： + 左移 + 右移 * 复合...
面向对象程序设计：JavaSE-任务81
08-08
面向对象程序设计是Java语言的核心特性之一，JavaSE（Java标准版）提供了丰富的类库来支持这一编程模型。在任务81中，我们将探讨四个关键主题：字符串、异常处理、日期处理以及静态方法。 首先，关于字符串，Java中...
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
03-03
- **对象与类**：Java是一种面向对象的语言，理解类和对象的概念，如何创建、实例化以及它们之间的关系至关重要。 - **封装、继承和多态**：这是面向对象的三大特性，封装确保数据安全，继承实现代码复用，多态...
面向对象程序设计：JavaSE-任务71
08-08
任务71是一个基于Java的图书馆借阅系统项目，旨在锻炼学生对面向对象编程的理解和应用，包括类的设计、封装、继承和多态。 在这个项目中，你需要设计一系列的类来代表图书馆的不同实体，如会员（Member）、图书...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 1143
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 1135
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 1531
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 2099
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 1868
linux上datax 安装以及使用
基于jenkins部署maven项目
静水深流
08-26 816
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 1188
@Transactional中使用线程锁导致了锁失效与解决方案
Java学习_18_Stream流
qq_41136689的博客
08-23 1612
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 510
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
旺旺老师JavaSE教程：类与对象解析
旺旺老师的《旺旺老师JavaSE教程》是一本针对初学者友好的Java编程教材，它以通俗易懂的语言和生动的案例，帮助学习者掌握Java编程的基础——类与对象，同时也能满足有经验的开发者寻求技术提升的需求。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值