Java之类和对象

于 2022-11-09 22:46:56 发布
阅读量840 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53190275/article/details/127777659
版权
本文深入浅出地介绍了面向对象编程的基础概念，包括面向对象的初步认知、类的定义与使用、实例化、this引用、构造与初始化、封装机制，以及静态成员和代码块。通过实例演示，帮助读者理解类和对象的关系，以及如何运用封装提升代码复用性和安全性。
摘要由CSDN通过智能技术生成

目录

1. 面向对象的初步认知

1.1 什么是面向对象

1.2 面向对象与面向过程

2. 类定义和使用

2.1 简单认识类

2.2 类的定义格式

2.3 课堂练习

2.3.1 定义一个类

3. 类的实例化

3.1 什么是实例化

3.2 类和对象的说明

3.3引用

4. this引用

4.1 为什么要有this引用

4.2 什么是this引用

4.3 this引用的特性

5. 对象的构造及初始化

5.1 如何初始化对象

5.2 构造方法

5.2.1 概念

5.2.2 特性

5.3 默认初始化

5.4 就地初始化

6. 封装

6.1 封装的概念

6.2 访问限定符

6.3 封装扩展之包

6.3.1 包的概念

6.3.2 导入包中的类

6.3.3 自定义包

6.3.4 包的访问权限控制举例

6.3.5 常见的包

7. static成员

7.1 再谈学生类

7.2 static修饰成员变量

7.3 static修饰成员方法

7.4 static成员变量初始化

8. 代码块

8.1 代码块概念以及分类

8.2 普通代码块

8.3 构造代码块

8.4静态代码块

1. 面向对象的初步认知

1.1 什么是面向对象

       Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

1.2 面向对象与面向过程

        面向对象是相对面向过程而言的，而面向对象包含了面向过程的思想。面向过程是分析出解决问题所需要的步骤，关注的是解决问题需要哪些步骤，而面向对象是把构成问题事务分解成各个对象，关注的是解决问题需要哪些对象。

       注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

2. 类定义和使用

       面相对象程序设计关注的是对象，而对象是现实生活中的实体

2.1 简单认识类

      类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些

2.2 类的定义格式

      在java中定义类时需要用到class关键字，具体语法如下

//创建类
class ClassName{
     field;//成员变量
     method;//成员方法
}
  • class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
  • 类中包含的内容称为类的成员。
  • 属性主要是用来描述类的，称之为类的成员属性或者类成员变量。

编译器会给默认值， 引用类型(null);int(0);float(0.0);boolean(false)

  • 注：1.成员变量是定义在类的内部，方法的外部

              2.局部变量是定义在方法（包括main方法）的内部

  • 方法主要说明类具有哪些功能，称为类的成员方法。
class WashMachine{
    public String brand; // 品牌
    public String type; // 型号
    public double weight; // 重量
    public double length; // 长
    public double width; // 宽
    public double height; // 高
    public String color; // 颜色
    public void washClothes(){ // 洗衣服
        System.out.println("洗衣功能");
    }
    public void dryClothes(){ // 脱水
        System.out.println("脱水功能");
    }
    public void setTime(){ // 定时
        System.out.println("定时功能");
    }
}

采用Java语言将洗衣机类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。

注意事项

  • 类名注意采用大驼峰定义
  • 成员前写法统一为public
  • 此处写的方法不带 static 关键字

2.3 课堂练习

2.3.1 定义一个类

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

注意事项：

1.一个java文件只能有一个public类

2. main方法所在的类一般要使用public修饰

3. public修饰的类必须要和文件名相同(可修改文件和类的名字）

修改方法：Refactor->Rename

4. 不要轻易去修改public修饰的类的名称

3. 类的实例化

3.1 什么是实例化

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Main{
    public static void main(String[] args) {
        PetDog dog = new PetDog(); //通过new实例化对象，PetDog是类名
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
    }
}

注意事项

  1. new 关键字用于创建一个对象的实例.
  2. 使用 . 来访问对象中的属性和方法.
  3. 同一个类可以创建多个实例.

3.2 类和对象的说明

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

3.3引用

1.一个引用赋值为null时,表示不指向任何对象

public static void main(String[] args) {
    //代表person1不指向任何对象
    Person person1=null;
}

2.引用不能指向引用

public static void main(String[] args) {
    Person person1=new Person();
    Person person2=new Person();
    person1=person2;
    //person1指向了person2指向的对象（引用不能指向引用）
}

3.一个引用只能指向一个对象（引用存了对象的地址）

public static void main(String[] args) {
    //一个引用只能指向一个对象（引用存了对象的地址）
    Person person1=new Person();
    Person person1=new Person();
    Person person1=new Person();
}

4. this引用

4.1 为什么要有this引用

先看一个日期类的例子：

public class Test {
    public int year;
    public int month;
    public int day;
    public void setDay(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
    public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
        Test d1 = new Test();
        Test d2 = new Test();
        Test d3 = new Test();
// 对d1，d2，d3的日期设置
        d1.setDay(2020,9,15);
        d2.setDay(2020,9,16);
        d3.setDay(2020,9,17);
// 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Test类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。

但是细思之下有疑问：

1. 如果形参名不小心与成员变量名相同：

public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}

那函数体中到底是谁给谁赋值？

2. 三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和printDate函数如何知道打印的是那个对象的数据呢？

一切让this引用来揭开这层神秘的面纱。

4.2 什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

public class Date {
    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        //局部变量，优先选择
        //加上this表示给当前对象赋值
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2020,9,15);
        d.printDate();
    }
}

注意：this引用的是调用成员方法的对象。

4.3 this引用的特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this只能在"成员方法"中使用

3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

5. 对象的构造及初始化

5.1 如何初始化对象

在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

局部变量：方法内部（包括main方法）

public static void main(String[] args) {
    int a;
    System.out.println(a);
}
// Error:(26, 28) java: 可能尚未初始化变量a

要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：

public static void main(String[] args) {
    Date d = new Date();
    d.printDate();
    d.setDate(2021,6,9);
    d.printDate();
}
// 代码可以正常通过编译

局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

5.2 构造方法

5.2.1 概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

public class Test {
    public int year;
    public int month;
    public int day;
    // 构造方法：
// 名字与类名相同，没有返回值类型，设置为void也不行（不能加void）
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Test(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
// 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Test d = new Test(2021,6,9); // 输出Date(int,int,int)方法被调用了
        d.printDate(); // 2021-6-9
    }
}

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

5.2.2 特性

1. 名字必须与类名相同

2. 没有返回值类型，不能用void

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)（例如 Test d = new Test();）

4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

public class Test {
    public int year;
    public int month;
    public int day;
    // 无参构造方法
    public Test(){
        this.year = 1900;
        this.month = 1;
        this.day = 1;
    }
    // 带有三个参数的构造方法
    public Test(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        Test d = new Test();
        d.printDate();
    }
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

public class Test {
    public int year;
    public int month;
    public int day;
    //生成默认的无参构造方法
    //public void Test(){
    // }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        Test d = new Test();
        d.printDate();
    }
}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。

public class Test {
    public int year;
    public int month;
    public int day;
    //构造方法有参时，要定义构造方法，否则会报错
    public Test(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
// 如果编译器会生成，则生成的构造方法一定是无参的
// 则此处创建对象是可以通过编译的
// 但实际情况是：编译期报错
        Test d = new Test();
        d.printDate();
    }
}
/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
需要: int,int,int
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
*/

6. 构造方法中，可以通过this调用其他构造方法来简化代码

this(1900,1,1);

无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
 但是this(1900,1,1);必须是构造方法中第一条语句

public class Test {
    public int year;
    public int month;
    public int day;

    public Test(){
        //System.out.println("1");  如果不注释，就会报错
        //构造方法的第一行
        this(1900, 1, 1);

    }
    // 带有三个参数的构造方法
    public Test(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

  • 不能形成环
public Date(){
    this(1900,1,1);
}
public Date(int year, int month, int day) {
    this();
}
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，
形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

7. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰

5.3 默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

public class Date {
    public int year;
    public int month;
    public int day;
    public Date(int year, int month, int day) {
        // 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
    }
    public static void main(String[] args) {
        // 此处a没有初始化，编译时报错：
        // Error:(24, 28) java: 可能尚未初始化变量a
        // int a;
        // System.out.println(a);
        Date d = new Date(2021,6,9);
    }
}

要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

Date d = new Date(2021,6,9);

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

1. 检测对象对应的类是否加载了，如果没有加载则加载

2. 为对象分配内存空间

3. 处理并发安全问题

比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突

4. 初始化所分配的空间

即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值

5. 设置对象头信息(关于对象内存模型后面会介绍)

6. 调用构造方法，给对象中各个成员赋值

5.4 就地初始化

在声明成员变量时，就直接给出了初始值。

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
    public Date(){
    }
    public Date(int year, int month, int day) {
    }
    public static void main(String[] args) {
        Date d1 = new Date(2021,6,9);
        Date d2 = new Date();
    }
}

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

6. 封装

6.1 封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

6.2 访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

private 当前类中访问

default 当前包中访问

protected 同一包中，不同包中的子类

public 都可以

class Student{
    private String name;
    public int age;
    public void show(){
        System.out.println("名字"+name);
    }
        }
public class Test2 {
    public static void main(String[] args) {
        Student student1=new Student();
       //student1.name="张三";  err 在不同类中，private修饰的变量不能访问
    }
}

【说明】

  • 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性
public class Computer {
    private String cpu; // cpu
    private String memory; // 内存
    public String screen; // 屏幕
    String brand; // 品牌---->default属性
    public Computer(String brand, String cpu, String memory, String screen) {
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
    }
    public void Boot(){
        System.out.println("开机~~~");
    }
    public void PowerOffff(){
        System.out.println("关机~~~");
    }
    public void SurfInternet(){
        System.out.println("上网~~~");
    }
}
public class Test {
    public static void main(String[] args) {
        Computer p = new Computer("HW", "i7", "8G", "13*14");
        System.out.println(p.brand); // default属性：只能被本包中类访问
        System.out.println(p.screen); // public属性： 可以任何其他类访问
// System.out.println(p.cpu); // private属性：只能在Computer类中访问，不能被其他类访问
    }
}

注意：一般情况下成员变量设置为private，成员方法设置为public。

6.3 封装扩展之包

6.3.1 包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

6.3.2 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类.

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

但是这种写法比较麻烦一些, 可以使用 import语句导入包.

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

不是把所有的都导入，而是用哪个类就导哪个类，随用随取

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
    }
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

在这种情况下需要使用完整的类名

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些.
        // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.pr intln(result);
    }
}

注意事项: import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.

import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

6.3.3 自定义包

基本规则

  • 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
  • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
  • 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
  • 如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2. 在弹出的对话框中输入包名, 例如 com.bit.demo1

3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

6.3.4 包的访问权限控制举例

Computer类位于com.bit.demo1包中，TestComputer位置com.bit.demo2包中：

package com.bit.demo1;
public class Computer {
        private String cpu; // cpu
        private String memory; // 内存
        public String screen; // 屏幕
        String brand; // 品牌
        public Computer(String brand, String cpu, String memory, String screen) {
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
    }
    public void Boot(){
        System.out.println("开机~~~");
    }
    public void PowerOffff(){
        System.out.println("关机~~~");
    }
    public void SurfInternet(){
        System.out.println("上网~~~");
    }
}
    
    package com.bite.demo2;
    import com.bite.demo1.Computer;
    public class TestComputer {
    public static void main(String[] args) {
        Computer p = new Computer("HW", "i7", "8G", "13*14");
        System.out.println(p.screen);
        // System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问
        // System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
        }
     }
// 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败

6.3.5 常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

7. static成员

7.1 再谈学生类

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

class Student{
    private String name;
    private int age;
    //static 静态修饰成员变量
    public static String classRoom="101";
    private static int size=10;
    public Student(String name, int age){
        this.name=name;
        this.age=age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1=new Student("kyd",16);
        Student student2=new Student("kyh",15);
        Student student3=new Student("kyf",10);
        System.out.println(Student1.classRoom);
        System.out.println(Student2.classRoom);
        System.out.println(student3.classRoom);
    }

假设三个同学是同一个班的，那么添加教室这个属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

7.2 static修饰成员变量

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

【静态成员变量特性】

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

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

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

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

class Student{
    public String name;
    public int age;
    //static 静态修饰成员变量
    public static String classRoom="101";

    public Student(String name, int age) {
        this.name=name;
        this.age=age;
    }
}
public class Test2 {
    public static void main(String[] args) {
  // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student student1=new Student("kyd",16);
        Student student2=new Student("kyh",15);
        Student student3=new Student("kyf",10);
 // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(Student1.classRoom);
        System.out.println(student2.classRoom);
        System.out.println(student3.classRoom);
    }
}

在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中。

7.3 static修饰成员方法

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

class Student{
    private String name;
    private int age;
    //static 静态修饰成员变量
    private static String classRoom="101";

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

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

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

class Student{
    private String name;
    private int age;
    //static 静态修饰成员变量
    private static String classRoom="101";

    public static String getClassRoom() {
        return classRoom;
    }

    public Student(String name, int age) {
        this.name=name;
        this.age=age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
}

【静态方法特性】

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()

5. 静态方法无法重写，不能用来实现多态

7.4 static成员变量初始化

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

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

1. 就地初始化

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

 private static String classRoom = "101";

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 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

 //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

8.4静态代码块

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

 // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

注意事项

  • 静态代码块不管生成多少个对象，其只会执行一次
  • 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
  • 静态代码块-》非静态代码块-》构造代码块（执行顺序）
class Student{

    private int age;
    //static 静态修饰成员变量
    public static String classRoom="101";
    private static int size=10;

    {
        name="caocao";
        System.out.println("非静态代码块/实例代码块/构造代码块-》初始化非静态成员");
    }
    static{
        System.out.println("静态代码块/实例代码块/构造代码块-》初始化静态成员");
    }
    public String name="1";
    public Student() {
        System.out.println("不带参数的构造方法");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1=new Student();
        System.out.println(student1.name);
    }
}
//运行结果
静态代码块/实例代码块/构造代码块-》初始化静态成员
非静态代码块/实例代码块/构造代码块-》初始化非静态成员
不带参数的构造方法
1
  • 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
  • 实例代码块只有在创建对象时才会执行

沐晴0128
关注
Java-类和对象
12-22
功能：初始化当前类对象中保存的成员变量数据。 一个类当中没有显式的声明构造方法的时候，Java编译器会默认的为其提供一个无参的构造方法，供其使用。 如果在一个类当中显式的声明了构造方法，不管式无参还是有参，...
Java之类和对象（上）
quanydi的博客
01-01 152
今年第一篇博客。 我来讲一下类和对象
Java中的类和对象
罗舒淇的博客
04-15 3443
文章目录一、类和对象的初步认识1.1 类和对象的基本概念1.2 类和类的实例化二、面向对象的封装性2.1 封装的基本概念及用法2.2 getter和setter方法三、构造方法3.1 基本语法3.2 new执行过程3.3 构造方法的重载四、this关键字4.1 调用当前对象的成员变量4.2 this调用类中的方法1. this调用类中的成员方法2.this调用构造方法3.this表示当前对象的引用五、代码块5.1 普通代码块5.2 成员代码块5.3 静态代码块 一、类和对象的初步认识 1.1 类和对象的基
JAVA逻辑 第十一章:类和对象
qq_36074150的博客
09-07 2198
对象：用来描述客观事物的一个实体,由一组属性和方法构成。　　类的特征（属性）和行为（方法）：              类的属性：对象所拥有的静态特征在类中表示时称为类的属性。               类的方法：对象执行的操作称为类的方法。       类和对象的关系是抽象和具体的关系。类是对象的类型，对象是类的实例。      对象的属性和方法被共同封装在类中，相辅相成，不可分割。   面向
Java~类和对象（类的定义方式以及对象的实例化、static、this关键字详解，了解封装、了解private、protected、public的区别、构造方法）
qq_58284486的博客
02-22 1397
目录 类的定义和实例化 类和对象是什么？ 类的定义格式 类的实例化 关键字详解 static关键字 this关键字 封装 访问限定符（private、default、protected、public） 构造方法 类的定义和实例化 Java是一门面向对象的语言，在面向对象的世界里，一切皆对象。面向对象是一种解决问题的思想，主要依靠对象与对象之间的交互完成一件事情。 类和对象是什么？ 类是用来对一个实体（对象）来进行描述的，主要描述实体（对象）有哪些属性、有哪些功能，类是..
java中的类和对象通俗讲解(含有代码例子)
快乐学习
07-30 1398
类（女生）就是一个简单模板，谁要用谁就调用。你调用了类，那你就变成了对象（女朋友）了哦，那你可要好好对这个类进行完善以成为你想要的。第二个女朋友同理。）中一个好看（beautiful）的方法就好了，不想结婚就不调用爱（love）的方法就好了。还有叫她表现什么行为由你决定，爱，结婚（看需要调用类（）里面的一些基本属性，比如（名字、年龄、爱好））里面的一些行为，比如（吃饭，好看，结婚）调用女生成为你的女朋友，那你就要给她（......
java学习之Java 对象和类
最新发布
01-06
Java是一种面向对象的编程语言，其核心理念是将现实世界中的实体抽象成代码中的对象，以便更好地模拟和处理复杂的问题。在Java中，对象是程序的基本单元，它们具有状态（属性）和行为（方法）。状态是由对象的属性来...
java基础-类和对象的定义
05-21
通过书籍，个人整理的java基础之类的对象的定义的有关知识点
Java对象和类 最详细说明
04-22
### Java对象和类 最详细说明 #### 一、Java中的对象 在面向对象编程中，对象是核心概念之一。对象可以被理解为现实世界中事物的抽象表示，它具有特定的状态（属性）和行为（方法）。例如，一辆汽车可以被视为一个...
简单了解JAVA中类、实例与Class对象
08-25
因此，每个类在Java中都有一个与之对应的Class对象，这个对象包含了类的类型信息，并且可以在运行时被创建。这个Class对象是类的“类”，是类的元数据表示形式。 获取Class对象有几种方式。首先，可以通过实例对象...
使用Java理解程序逻辑第11章.zip
04-20
【原创作者田超凡，未经许可请勿转发，侵权仿冒必究】
Java面向对象编程之类的继承详解
08-28
"Java面向对象编程之类的继承详解" Java面向对象编程之类的继承是Java编程语言中最基本也是最重要的概念之一。继承是类和类之间的一种关系，通过继承，可以使子类继承父类的所有属性和方法，从而提高代码的复用性和...
java类和对象笔记
01-14
### Java 类与对象知识点 #### 一、万物皆对象 在Java编程中，**万物皆对象**是一个核心理念。...面向对象的思想贯穿于整个Java编程语言的设计之中，掌握这些基础知识对于成为一名合格的Java程序员至关重要。
Java和面向对象概述.pptx
11-21
学习Java和面向对象编程，需要掌握基础概念，如类、对象、属性、方法、构造器、继承、多态、接口、包等，并理解面向对象的设计原则，如单一职责原则、开放封闭原则、里氏替换原则、依赖倒置原则等。此外，还要熟悉...
java中类和对象的定义及使用（1）
weixin_40458508的博客
11-20 976
1.类和对象：Java的学习过程中类和对象往往在一起出现与使用，那么我们怎么去理解和学习呢？ 1.1 类：类是具有共同属性和行为的事物，比如我们在进行班级成员统计时，每个学生都要求统计姓名，年龄，学号，家庭地址。我们可以将这些认为是学生这个类所具有共同属性，每个学生要求上课，考试，我们又可以将这些认为是学生这个类具有的共同行为。大多数情况下，我们用成员变量表示类的属性，用成员方法表示类的行为。 那么我们就可以在程序中简单的定义学生为一个类。类的简单定义如下： public class ...
java类和对象
weixin_54342360的博客
02-24 389
对Java中类、内部类、构造方法、包以及封装展开介绍
Java基础——类和对象
热门推荐
explorer363的博客
04-26 3万+
本篇博客介绍了Java中类和对象的基本内容，看完本篇博客后，希望大家能对类和对象能有进一步的了解
Java类与对象练习题
张子又
12-10 1万+
请定义一个交通工具(Vehicle)的类其中有: 属性： 速度(speed)、 体积(size)等，方法：移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速...
Java类与对象：属性和方法解析
本文将深入探讨Java中的类和对象，这是Java编程的基础概念。类是对象的蓝图，定义了对象的属性（数据成员）和方法（功能）。对象则是类的实例，具备类所定义的特性。 在Java中，类用于封装数据和行为。描述中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值