类变量/方法、main语法、代码块

news2024/9/27 15:32:20

一.类变量和方法

思维导图概览：

1.1类变量（静态变量）

1.什么叫做类变量/方法？

——给类中的成员属性或成员方法加上static关键字进行修饰，类变量/方法也叫做静态变量/方法，静态变量/方法被类的自身所有对象所共享使用

 

2.一个小case快速了解类变量/方法

public class Test {
    public static void main(String[] args) {
        //静态属性可以直接使用类名访问，也可以使用对象名访问，但是遵守访问权限
        System.out.println(Animal.getAge());//18
        Animal jack = new Animal("jack");
        System.out.println(jack.getAge());//18
    }
}

class Animal {
    //成员变量
    private String name;
    //类变量
    private static int age;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //静态方法
    public static int getAge() {
        age = 18;
        return age;
    }
}

 

3.类变量的内存布局

由图可知：

        1）static变量（静态变量）被类的所有对象共享，这些对象均属于同一个类

        2）静态变量，在类加载的时候就生成了

 

4.静态变量的定义和访问

1）静态变量的定义

        i.访问修饰符 static 数据类型 变量名；（推荐）

        ii.static 访问修饰符 数据类型 变量名;

2）静态变量的访问

        i.类名.静态变量名（推荐）

        ii.对象名.静态变量名

public class Test {
    public static void main(String[] args) {
        //访问静态变量的两种方式
        //类名.静态变量名
        //静态变量随着类的加载而创建，所有不需要使用创建对象去访问
        System.out.println("姓名：" + Animal.name + "年龄：" + Animal.age);

        //对象名.静态变量名
        Animal animal = new Animal();
        System.out.println("姓名：" + animal.name + "年龄：" + animal.age);
    }
}

class Animal {
    //静态变量的两种定义方式
    //静态变量也需要遵守访问权限
    public static String name = "大黄"; //推荐使用这种方式
    static public int age = 18;
}

 

5.静态变量的细节讨论

1）什么时候需要使用静态变量？

当需要让所有对象都需要共享某一个变量的时候，那我们可以把这个变量设置为静态变量

2）静态变量和成员属性的区别

        i.静态变量被同类的所有对象共享

        ii.成员属性被每个对象独享，对象与对象之间的成员属性均独立

3）静态变量无需使用对象名访问，即没有创建对象，也能访问类变量

4）静态变量的生命周期随着类的加载而生成，随着类的销毁而消亡

public class Test {
    public static void main(String[] args) {
        //成员属性在每个对象之间均是独立的
        Person jack = new Person("jack", 18);
        Person marry = new Person("marry", 19);

        //静态变量赋值
        marry.setSalary(10000);
        System.out.println(jack.getSalary());//10000
        System.out.println(marry.getSalary());//10000
    }
}

class Person {
    //成员属性
    private String name;
    private int age;

    //静态变量
    public static char gender = '男';
    //若是没有给静态变量赋值，应该提供一个set方法进行赋值
    private static double salary;

    //构造器
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //若是静态变量是私有的，那我们提供get/set进行赋值和取值
    public void setSalary(double salary) {
        //为了区分两个salary，静态变量使用类名.salary
        Person.salary = salary;
    }

    public double getSalary() {
        return Person.salary;
    }
}

 

1.2类方法（静态方法）

1.静态方法的定义和访问

1）静态方法的定义

        i.访问修饰符 static 返回的数据类型 方法名(参数列表){};(推荐)

        ii.static 访问修饰符 返回的数据类型 方法名(参数列表){};

2）静态方法的访问方式

        i.使用类名.静态方法名访问

        ii.使用对象.静态方法名

public class Test {
    public static void main(String[] args) {
        //静态方法的访问形式
        //形式1：类名.静态方法名
        Person.say();
        Person.hi();
        
        //形式2：对象名.静态方法名
        Person person = new Person();
        person.say();
        person.hi();
    }
}

class Person {
    //静态方法的定义方式
    //定义1：访问修饰符 static 返回的数据类型 方法名(形参列表) {}
    public static void say() {
        System.out.println("Hello,bro");
    }

    //定义2：static 访问修饰符 返回的数据类型 方法名(形参列表) {}
    static public void hi() {
        System.out.println("HI,bro");
    }
}

 

2.静态方法的使用场景

——当方法中不涉及任何和对象相关的成员，则可以设置为静态方法

注：工具类中的方法均为静态方法，提高了开发效率

 

3.静态方法的细节讨论

1）静态方法的加载和普通成员方法的加载均是随着类的加载而加载的，将结构信息存储在方法区

2）静态方法中不能使用this和super关键字，为什么？

        ——因为静态方法不需要创建对象就能访问，而this和super关键字需要对象才能使用

public class Test {
    public static void main(String[] args) {
        Stu.say();
    }
}

class Person {
    public int age = 18;
}

class Stu extends Person {
    //成员属性
    private String name = "jack";

    //构造器
    public Stu() {
    }

    //静态方法中不能使用this和super关键字
    public static void say() {
        //System.out.println("name=" + this.name);
        //System.out.println(super.age);
        System.out.println("Hello,bro");
    }
}

3）普通成员方法和静态方法的访问规则

        i.普通方法能访问静态属性和普通成员属性

        ii.静态方法只能访问静态属性

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.bye();
        Person.hi();
    }
}

class Person {
    //注：方法和变量称为属性
    //普通成员变量
    private String name;
    private int age;
    //静态变量
    private static double salary = 10000.0;

    //普通成员方法
    public void say() {
        System.out.println("Hello");
    }

    //普通成员方法能访问静态属性和普通成员属性
    public void bye() {
        //普通成员属性
        say();//普通方法
        System.out.println(name);//普通成员
        System.out.println(age);

        //静态属性
        hi();//静态方法
        System.out.println(Person.salary);//静态变量
    }

    //静态方法只能访问静态属性
    public static void hi() {
        ok();//静态方法
        System.out.println(Person.salary);//静态变量

        //System.out.println(age);错误
    }

    public static void ok() {
        System.out.println("Ok~");
    }
}

 

 

二.main语法

思维导图概览：

1.什么是main方法?

——main方法是程序的主方法，一个程序只能有一个main方法，main方法是程序的入口

 

2.main方法的作用

——main方法的作用是为了Java虚拟机对程序的调用，main方法起了一个入口的作用

 

3.main方法的语法详解

public static void main(String[] args) {}

解释：

1）为什么需要pubic访问修饰符？

        ——因为Java虚拟机需要在类外调用main方法，所以main方法的访问权限必须是public

2）为什么需要static关键字？

        ——因为使用了static关键字后，我们不需要创建对象就能访问main方法

3）为什么需要使用void关键字？

        ——因为main方法我们不要求它给我们返回值，即是void

4）String[] args的作用是什么？

        ——String[] args接收命令行中的字符串

 

4.小tips

1）在main方法中，只能直接调用本类的静态属性，不能直接调用本类的非静态方法

2）不能直接调用的非静态属性，需要创建对象后访问

public class Test {
    private int age = 18;
    public static int sal = 10000;
    
    public static void main(String[] args) {
        //在main方法中可以直接访问静态属性
        System.out.println(sal);
        //main方法中需要创建对象后后才嫩访问成员属性
        Test test = new Test();
        System.out.println(test.age);
    }
}

 

 

三.代码块

思维导图概览：

1.什么是代码块？

——代码块属于类中的成员，是类的一部分，类似于方法，代码块将逻辑语句使用{}包括起来；代码块没有方法名，返回参数，参数列表，只有方法体，不能通过类的显示调用，只能隐式使用

 

2.代码块语法

语法：

(修饰符) {

        代码

};

注：

1）修饰符只有static可选

2）代码块分为静态代码块和普通代码块，静态代码块使用static修饰

3）代码块内可以写任何逻辑语句

4）;号可写可不写

public class Test {
    public static void main(String[] args) {
    }
}

class Person {
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
    
    //普通代码块
    {
        System.out.println("普通代码块");
    }
}

 

3.代码块的优点

1）相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化操作

2）如果多个构造器中有相同的语句，可以抽取到代码块中去进行初始化，可以完成代码的重用性

 

4.一个小case快速了解代码块

public class Test {
    public static void main(String[] args) {
        Person person = new Person("jack", 18);
    }
}

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

    //静态代码块
    static {
        System.out.println("静态代码块");//静态代码块
    }

    //普通代码块
    {
        System.out.println("普通代码块");//普通代码块
    }

    //构造器
    public Person(String name, int age) {
        System.out.println("构造器器初始化~");//构造器器初始化~
        this.name = name;
        this.age = age;
    }

    //方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

 

5.代码块的细节讨论

1）static修饰的代码块叫做静态代码块，作用是对类进行初始化，它随着类的加载而执行，只会执行一次

2）实例代码块的执行随着对象的创建就会执行，有几个对象则执行几次实例代码块

public class Test {
    public static void main(String[] args) {
        //创建了四个对象：静态代码块只会执行一次，普通代码块有几个对象则执行几次
        //输出一次静态代码块，输出四次普通代码块
        Person p = new Person();
        Person p1 = new Person();
        Person p2 = new Person();
        Person p3 = new Person();
    }
}

class Person {
    //静态代码块
    static {
        System.out.println("静态代码块");//静态代码块
    }

    //普通代码块
    {
        System.out.println("普通代码块");//普通代码块
    }
}

3）类在什么时候进行加载？

        i.创建对象实例的时候进行类的加载

        ii.创建子类对象实例，父类也会被进行加载，先加载父类

        iii.使用静态成员时进行类加载

public class Test {
    public static void main(String[] args) {
        //注：每个测试用例单独测试
        //创建对象实例的时候进行类的加载
        //Person person = new Person("jack",18);
        //输出：父类的静态代码块~   父类的普通代码块~   父类的构造器~

        //创建子类对象实例，先进行父类和子类的静态代码块，然后进行加载父类，再加载父类
        //Stu stu = new Stu("marry",16);
        //输出：父类的静态代码块~  子类的静态代码块~  父类的普通代码块~  父类的构造器~  子类的普通代码块~  子类的构造器~

        //使用静态成员时进行类加载
        System.out.println(Stu.gender);
        //输出：父类的静态代码块~  子类的静态代码块~  男
    }
}

class Person {
    //成员属性
    private String name;
    private int age;

    //静态代码块
    static {
        System.out.println("父类的静态代码块~");
    }

    //普通代码块
    {
        System.out.println("父类的普通代码块~");
    }

    //构造器
    public Person(String name, int age) {
        System.out.println("父类的构造器~");
        this.name = name;
        this.age = age;
    }

    //方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Stu extends Person {
    //静态变量
    public static char gender = '男';

    public Stu(String name, int age) {
        super(name, age);
        System.out.println("子类的构造器~");
    }

    //静态代码块
    static {
        System.out.println("子类的静态代码块~");
    }

    //普通代码块
    {
        System.out.println("子类的普通代码块~");
    }
}

4）在单个类中，创建一个对象时，类的调用顺序如下：

        i.先调用静态成员初始化，静态代码块、静态属性的优先级一样，先定义的先调用

        ii.然后调用普通代码块和普通成员属性初始化，优先级相同，先定义的先调用

        iii.最后调用构造器

public class Test {
    public static void main(String[] args) {
        Person jack = new Person("jack", 18);
        //输出：父类的静态代码块~  父类的普通代码块~  父类的构造器~
    }
}

class Person {
    //1）在类中先调用静态成员初始化，静态代码块、静态属性的优先级一样，先定义的先调用
    //静态成员
    public static char gender = '男';

    //静态代码块
    static {
        System.out.println("父类的静态代码块~");
    }

    //2）调用普通代码块和普通成员属性初始化，优先级相同，先定义的先调用
    //成员属性
    private String name;
    private int age;

    //普通代码块
    {
        System.out.println("父类的普通代码块~");
    }

    //3）调用构造器
    //构造器
    public Person(String name, int age) {
        System.out.println("父类的构造器~");
        this.name = name;
        this.age = age;
    }

    //方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

5）构造器前面隐含了super和普通代码块的调用，执行顺序: super > 普通代码块 > 构造器

public class Test {
    public static void main(String[] args) {
        Stu stu = new Stu();
        //输出：父类的普通代码块~  父类的构造器~  子类的普通代码块~  子类的构造器~
    }
}

//父类
class Person {
    //代码块
    {
        System.out.println("父类的普通代码块~");
    }

    //构造器
    public Person() {
        System.out.println("父类的构造器~");
    }
}

//子类
class Stu extends Person {
    //代码块
    {
        System.out.println("子类的普通代码块~");
    }

    //构造器
    public Stu() {
        System.out.println("子类的构造器~");
    }
}

6）当存在继承关系的时候，子类创建对象后，类的调用顺序为：

        前提：成员 = 成员变量 + 成员方法

        i.调用父类的静态成员对类进行初始化，若有多个静态成员，则按照定义顺序优先

        ii.调用子类的静态成员对类进行初始化，若有多个静态成员，则按照定义顺序优先

        iii.调用父类普通成员对类进行初始化，若有多个普通成员，则按照定义顺序优先

        iv.调用父类的构造器

        v.调用子类普通成员对类进行初始化，若有多个普通成员，则按照定义顺序优先

        vi.调用子类的构造器

public class Test {
    public static void main(String[] args) {
        Stu stu = new Stu();
        //输出：父类的静态代码块~  子类的静态代码块~  父类的普通代码块~ 父类的构造器~  子类的普通代码块~  子类的构造器~
    }
}

class Person {
    //代码块
    static {
        System.out.println("父类的静态代码块~");
    }

    {
        System.out.println("父类的普通代码块~");
    }

    //构造器
    public Person() {
        System.out.println("父类的构造器~");
    }
}

class Stu extends Person {
    //代码块
    static {
        System.out.println("子类的静态代码块~");
    }

    {
        System.out.println("子类的普通代码块~");
    }

    //构造器
    public Stu() {
        System.out.println("子类的构造器~");
    }
}

7）静态代码块只能调用静态属性，普通代码块可以任意调用

public class Test {
    public static void main(String[] args) {
    }
}

class Person {
    //静态成员变量
    private static int id = 52213234;
    
    //静态代码块
    static {
        //静态代码块只能调用静态成员
        //say();//错误
        hi();
        System.out.println(id);
    }

    //普通代码块
    {
        //普通代码块能调用任意成员
        System.out.println(Person.id);
        say();
        Person.hi();
    }
    
    //普通方法
    public void say() {
        System.out.println("普通say()方法~");
    }
    
    //静态方法
    public static void hi() {
        System.out.println("静态hi()方法~");
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1151419.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C/C++ 飞翔的小鸟

C/C++ 飞翔的小鸟

载入问题： 解决之后效果： 放在main函数里面进行封装： 效果展示: 实现下坠 放进while（1）里面不断进入循环，每次进入循环，鸟的y坐标值就会发生变化，以此实现下下坠效果 效果展示&#…
阅读更多...
取消Excel打开密码的两种方法

取消Excel打开密码的两种方法

Excel设置了打开密码，想要取消打开密码是由两种方法的，今天分享这两种方法给大家。 想要取消密码是需要直到正确密码的，因为只有打开文件才能进行取消密码的操作 方法一： 是大家常见的取消方法，打开excel文件之后&a…
阅读更多...
【python入门篇——7】循环控制（if、while、for、range）

【python入门篇——7】循环控制（if、while、for、range）

目录 一、条件和 If 语句 1.Python 支持来自数学的常用逻辑条件 2.缩进 3.Elif 4.Else 5.pass语句 二、While 循环 1.else 语句 三、for 循环 1.循环遍历字符串 2.Else 3.嵌套循环 4.pass 语句 四、range() 函数 1.range() 函数 2.起始参数 3.递增序列 一、条…
阅读更多...
Elasticsearch-8.10.4安装

Elasticsearch-8.10.4安装

1.官网下载 https://www.elastic.co/cn/downloads/elasticsearch#ga-release 下载的是Linux x86_64 包名为elasticsearch-8.10.4-linux-x86_64.tar.gz 2.服务器解压 tar -xvf elasticsearch-8.10.4-linux-x86_64.tar.gz 3.修改配置 编辑配置文件config/elasticsearch.y…
阅读更多...
ChineseChess.2023.10.30.01

ChineseChess.2023.10.30.01

中国象棋模拟器：黑子一步即杀的棋，红要解棋，不断将军慢慢把老帅边上棋子走开才有可能离开底线 【可以不上“士”的，将上去完事。】 不上【士】就没了，这局不知道咋破，哈哈 修改缺陷吧 中国象棋残局模拟器C…
阅读更多...
0-1背包问题【穷举法+二维dp数组】

0-1背包问题【穷举法+二维dp数组】

问题描述： 使用穷举法解决0/1背包问题。问题描述：给定n个重量为{w1, w2, … ,wn}、价值为{v1, v2, … ,vn} 的物品和一个容量为C的背包，求这些物品中的一个最有价值的子集，且要能够装到背包中。 穷举法：每件物品装还是…
阅读更多...
网络协议--TCP的未来和性能

网络协议--TCP的未来和性能

24.1 引言 TCP已经在从1200 b/s的拨号SLIP链路到以太数据链路上运行了许多年。在80年代和90年代初期，以太网是运行TCP/IP最主要的数据链路方式。虽然TCP在比以太网速率高的环境（如T2电话线、FDDI及千兆比网络）中也能够正确运行，但…
阅读更多...
项目一：员工管理系统

项目一：员工管理系统

一：项目功能 该项目应该具有以下功能： 1.查询所有员工 2.查询指定编号的员工 3.添加员工信息 4.修改员工信息 5.删除员工信息 6.退出功能 二：技能的使用 1.使用JDBC访问数据库 2.分层开发： 前台：调用后台，…
阅读更多...
【Qt】盒子布局、网格布局、表单布局和堆栈布局

【Qt】盒子布局、网格布局、表单布局和堆栈布局

盒子布局 QBoxLayout可以在水平方向或垂直方向上排列控件，分别派生了QHBoxLayout、QVBoxLayout子类。 QHBoxLayout：水平布局，在水平方向上排列控件，即：左右排列。QVBoxLayout：垂直布局，在垂直…
阅读更多...
测试环境内存溢出排查过程

测试环境内存溢出排查过程

基本信息 客户名称：xxx 产品名称： 版本号： 问题分类：编码问题 环境类型：实体机 问题现象 保险公司测试环境爆内存，机器挂掉。总共64g的内存，在没有开始测试tomcat部署war包前内存使用率为25%左…
阅读更多...
钉钉超过90天的文件需要一分钟重新激活的实现原理是什么？

钉钉超过90天的文件需要一分钟重新激活的实现原理是什么？

具体实现原理可能包括以下几点： 冷热数据分类：系统会根据文件的访问频率将文件分为热数据和冷数据两类。热数据是经常被访问的文件，这些文件会被存储在快速的存储设备上，以便快速访问。冷数据是很少被访问的文件，这些…
阅读更多...
2023.10.29.CODE_CHECK

2023.10.29.CODE_CHECK

阅读更多...
基于ROS发布里程计信息

基于ROS发布里程计信息

参考文档： navigationTutorialsRobotSetupOdom 参考博客： （1）ROS机器人里程计模型 （2）ROS里程计消息nav_msgs/Odometry的可视化方法 1 常用坐标系系统模型 世界坐标系是描述机器人全局信息的坐标系&#…
阅读更多...
洛谷 B2004 对齐输出 C++代码

洛谷 B2004 对齐输出 C++代码

目录 推荐专栏 题目描述 AC Code 切记 推荐专栏 http://t.csdnimg.cn/Z1tCAhttp://t.csdnimg.cn/Z1tCA 题目描述 题目网址&#xff1a;对齐输出 - 洛谷 AC Code #include<bits/stdc.h> using namespace std; typedef long long ll; int main() { int a,b,c;cin&g…
阅读更多...
【仙逆】尸阴宗始祖现身，王林修得黄泉生窍诀，阿呆惊险逃生

【仙逆】尸阴宗始祖现身，王林修得黄泉生窍诀，阿呆惊险逃生

【侵权联系删除】【文/郑尔巴金】 深度爆料最新集&#xff0c;王林终于成功筑基&#xff0c;这一集的《仙逆》动漫真是让人热血沸腾啊&#xff01;在这个阶段&#xff0c;王林展现出了他的决心和毅力&#xff0c;成功地击杀了藤厉&#xff0c;并采取了夺基大法&#xff0c;从藤…
阅读更多...
Hive On Spark 概述、安装配置、计算引擎更换、应用、异常解决

Hive On Spark 概述、安装配置、计算引擎更换、应用、异常解决

文章目录 Hadoop 安装Hive 安装Hive On Spark 与 Spark On Hive 区别Hive On SparkSpark On Hive 部署 Hive On Spark查询 Hive 对应的 Spark 版本号下载 Spark解压 Spark配置环境变量指定 Hadoop 路径在 Hive 配置 Spark 参数上传 Jar 包并更换引擎 测试 Hive On Spark解决依赖…
阅读更多...
Springboot的Container Images，docker加springboot

Springboot的Container Images，docker加springboot

Spring Boot应用程序可以使用Dockerfiles容器化&#xff0c;或者使用Cloud Native Buildpacks来创建优化的docker兼容的容器映像&#xff0c;您可以在任何地方运行。 1. Efficient Container Images 很容易将Spring Boot fat jar打包为docker映像。然而&#xff0c;像在docke…
阅读更多...
智能分析视频平台EasyCVR地图功能出现异常该如何解决？

智能分析视频平台EasyCVR地图功能出现异常该如何解决？

安防视频监控/视频集中存储/云存储/磁盘阵列EasyCVR平台可拓展性强、视频能力灵活、部署轻快&#xff0c;可支持的主流标准协议有国标GB28181、RTSP/Onvif、RTMP等&#xff0c;以及支持厂家私有协议与SDK接入&#xff0c;包括海康Ehome、海大宇等设备的SDK等。平台既具备传统安…
阅读更多...
41基于matlab的CNN的图像边缘提取，程序已调通，可直接运行。

41基于matlab的CNN的图像边缘提取，程序已调通，可直接运行。

基于matlab的CNN的图像边缘提取&#xff0c;程序已调通&#xff0c;可直接运行。 41matlabCNN图像边缘提取 (xiaohongshu.com)
阅读更多...
《AI时代架构师修炼之道：ChatGPT让架构师插上翅膀》

《AI时代架构师修炼之道：ChatGPT让架构师插上翅膀》

本专注于帮助架构师在AI时代 实现晋级、提高效率的图书 书中介绍了如何使用 ChatGPT 来完成架构设计的各个环节 并通过实战案例展示了ChatGPT在实际架构设计中的应用方法 关键点 1.架构设计新模式&#xff1a;让架构设计更高效、更快捷、更完美。 2.全流程解析&#xff1a;涵盖…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023