首页 > 编程语言 >【Java复健指南10】OOP高级01-类变量、类方法和main

【Java复健指南10】OOP高级01-类变量、类方法和main

时间:2022-11-07 22:58:19浏览次数:42  
标签:复健 01 Java 变量 静态 访问 static 方法 public

类变量

什么是类变量

类变量也叫静态变量/静态属性,是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。

如何定义类变量

定义语法:

访问修饰符 static 数据类型 变量名;【推荐】

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

访问方式

类名.类变量名,例子:

public class VisitStatic {
    public static void main(String[] args) {
        //类名.类变量名
        //说明:类变量是随着类的加载而创建,所以即使没有创建对象实例也可以访问
        System.out.println(A.name);
        A a = new A();
        //通过对象名.类变量名
        System.out.println("a.name=" + a.name);
    }
}

class A {
    //类变量
    //类变量的访问,必须遵守 相关的访问权限.
    public static  String name = "xxxx";
    //普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
    private int num = 10;
}

使用细节

1.什么时候需要用类变量

​ 当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量)

​ 比如:定义学生类,统计所有学生共交多少钱。Student (name, fee)

2.类变量与实例变量(普通属性)区别

​ 类变量是该类的所有对象共享的,而实例变量是每个对象独享的。

3.加上static称为类变量静态变量,否则称为实例变量/普通变量/非静态变量

4.类变量可以通过类名.类变量名或者对象名.类变量名来访问

​ 但java设计者推荐我们使用类名.类变量名方式访问。【前提是满足访问修饰符的访问权限和范围】

5.实例变量不能通过类名.类变量名方式访问。

6.类变量是在类加载时便初始化。

​ 也就是说,即使你没有创建对象,只要类加载了,就可以使用类变量了。

​ ps:补充一点个人理解,java中的静态变量和python中的静态修饰其实类似。前者没有创建对象实例也可以访问(因为其在类加载的时候就创建了),后者可以再没有实例化类函数的情况下直接使用类函数

7.类变量的生命周期是随类的加载开始,随着类消亡而销毁。

public class StaticDetail {
    public static void main(String[] args) {
        B b = new B();
        //System.out.println(B.n1);
        System.out.println(B.n2);
        //静态变量是类加载的时候,就创建了,所以我们没有创建对象实例
        //也可以通过类名.类变量名来访问
        System.out.println(C.address);
    }
}

class B {
    public  int n1 = 100;
    public static int n2 = 200;
}

class C {
    public static String address = "北京";
}

类方法

什么是类方法

类方法也叫静态方法。形式如下:

访问修饰符 static 数据返回类型 方法名(){}【推荐】

static 访问修饰符 数据返回类型 方法名(){}

类方法的调用

使用方式:类名.类方法名或者对象名.类方法名【前提是满足访问修饰符的访问权限和范围】

public class StaticMethod {
    public static void main(String[] args) {
        //创建2个学生对象交学费
        Stu jk = new Stu("jk");
        //jk.payFee(150);或者如下
        Stu.payFee(150);

        Stu cc = new Stu("cc");
        cc.payFee(300);

        Stu.showFee();
    }
}

class Stu{
    private String name;//普通成员
    //定义一个静态变量用于累计学费
    private static double fee = 0;
    public Stu(String name) {
        this.name = name;
    }
    //当方法使用static修饰之后就可以访问静态变量
    //即为静态方法
    public static void payFee(double fee){
        Stu.fee += fee;//累积
    }
    public static void showFee(){
        System.out.println("总学费为:"+Stu.fee);
    }
}

类方法的使用场景

当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率。

//如果我们希望不创建实例,也可以调用某个方法(即当做工具来使用)
//这时,把方法做成静态方法时非常合适
System.out.println("9开平方的结果是="” + Math.sqrt(9));

或者是自己开发工具类时,可将方法设为静态方法,方便调用

//求出两个数的和
class MyTools {
    public static double calSum(double n1,double n2) {
		return n1 + n2;
	}
}

还是类比Python

Java因为是原生支持OOP的语言,因此"类"是Java的核心

类方法就是一种简化使用类步骤的技巧,这样Java的类就更加接近Python中所谓的"函数"的使用方式

也就是:即调即用

使用细节

1.类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区:

​ 类方法中无this的参数;

​ 普通方法中隐含着this的参数;

2.类方法可以通过类名调用,也可以通过对象名调用。

3.普通方法和对象有关,需要通过对象名调用,比如对象名.方法名(参数),不能通过类名调用。

4.类方法中不允许使用和对象有关的关键字,比如this和super。普通方法(成员方法)可以。

5.类方法(静态方法)中只能访问静态变量或静态方法。【如何理解】

6.普通成员方法,既可以访问普通变量(方法),也可以访问静态变量(方法)。

小结:

静态方法,只能访问静态的成员;

非静态的方法,可以访问静态成员和非静态成员;(必须遵守访问权限)

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

        D.hi();//ok
        //非静态方法,不能通过类名调用
        //D.say();, 错误,需要先创建对象,再调用
        new D().say();//可以
    }
}
class D {

    private int n1 = 100;
    private static  int n2 = 200;
    public void say() {//非静态方法,普通方法

    }

    public static  void hi() {//静态方法,类方法
        //类方法中不允许使用和对象有关的关键字,
        //比如this和super。普通方法(成员方法)可以。
        //System.out.println(this.n1);
    }

    //类方法(静态方法)中 只能访问 静态变量 或静态方法
    //口诀:静态方法只能访问静态成员.
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);不能使用
        hi();//OK
        //say();//错误
    }
    //普通成员方法,既可以访问  非静态成员,也可以访问静态成员
    //小结: 非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

练习题for类变量与类方法

public class StaticExercise03 {
}

class Person { 
    private int id;
    private static int total = 0;
    public static void setTotalPerson(int total){
        // this.total = total;//错误,因为在static方法中,不可以使用this 关键字

        Person.total = total;//改成这样即可,意思就是访问静态变量
    }
    public Person() {//构造器
        total++;
        id = total;
    }
    //编写一个方法,输出total的值
    public static void m() {
        System.out.println("total的值=" + total);
    }
}
class TestPerson {
    public static void main(String[] args) {

        Person.setTotalPerson(3);
        new Person(); //最后 total的值就是4
        Person.m();//看看输出的是不是4
    }
}

main方法的语法

深入理解main方法

解释main方法的形式:public static void main(Stringargs){}

  1. main方法是由Java虚拟机调用的

  2. Java虚拟机需要调用类的main()方法,所以该方法的访问权限必须是public【因为JVM与main不在同一个类,不是public怎么调?】

  3. Java虚拟机在执行main()方法时不必创建对象,所以该方法必须是static

  4. 该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所运行的类的参数

    public class Hello {
        public static void main(String[] args){
        //args是如何传入
        //遍历显示
            for(int i =e; i < args. length; i++){
            	System.out.println("第"+(+1)+"个参数="+ args[i]);
            }
         }
    }
    ==================================================================
    D: \javacode>javac Hello.java
        
    D: \javacode>java Hello
        (无输出)
    D:javacode>java Hello tom jack smith
    第1个参数=tom
    第2个参数=jack
    第3个参数=smith
    
    

    上述过程表明多个输入参数会被打包成数组传入方法中

    即:String[] args的值是执行程序的时候传入的(面试问题)

  5. java 执行的程序 参数1 参数2 参数3

特别提示:

  1. 在main()方法中,我们可以直接调用main方法所在类的静态方法或静态属性。

  2. 但是,不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员。

public class Main01 {

    //静态的变量/属性
    private static  String name = "韩顺平教育";
    //非静态的变量/属性
    private int n1 = 10000;

    //静态方法
    public static  void hi() {
        System.out.println("Main01的 hi方法");
    }
    //非静态方法
    public void cry() {
        System.out.println("Main01的 cry方法");
    }

    public static void main(String[] args) {

        //可以直接使用 name
        //1. 静态方法main 可以访问本类的静态成员
        System.out.println("name=" + name);
        hi();
        //2. 静态方法main 不可以访问本类的非静态成员
        //System.out.println("n1=" + n1);//错误
        //cry();
        //3. 静态方法main 要访问本类的非静态成员,需要先创建对象 , 再调用即可
        Main01 main01 = new Main01();
        System.out.println(main01.n1);//ok
        main01.cry();
    }
}

标签:复健,01,Java,变量,静态,访问,static,方法,public
From: https://www.cnblogs.com/DAYceng/p/16867803.html

相关文章

  • java基础2
    类型转换Java运算时,需要用到类型转换运算中不同类型数据先转化为同一类型,然后进行运算两种转换方式强制转换自动转换publicclassDemo05{publics......
  • ArchLinux安装手册(2022-10-01)
    准备工作镜像下载:北京外国语大学镜像使用ventoy做启动盘:(1)ventoy下载:github下载地址(2)解压运行下载好的ventoy,设备选择准备好的U盘(会清空),然后选择安装即可。......
  • 从新开始学JAVA - 运算符9
    运算符运算符类型算术运算符:+,-,*,/,%,++,--赋值运算符:=关系运算符:>,<,>=,<=,==,!=,instanceof逻辑运算符:&&,||,!位运算符:&,|,^......
  • java线程 Thread
    packagecom.tedu.threadStudy;publicclassstudyThread{publicstaticvoidmain(String[]args){MyThreadth1=newMyThread("线程1");My......
  • 《Java程序设计——深入理解计算机系统的语言》上市了
    ​​​​本书是一部系统论述Java编程语言的体化教程(含纸质图书、教学课件、源代码与答疑服务)。书中主要内容包括:引言;开发环境搭建;第一个Java程序; Java语法基础;数据类型;运算......
  • Javascript(笔记25) - DOM基本操作 - 节点的四个属性
    Javascript(笔记25)-DOM基本操作-节点的四个属性所有的节点都有这四个属性节点的四个属性nodeName返回元素的标签名,以大写形式表示,只读;document 的nodeName 属性:以这......
  • 【Leetcode】 剑指offer:栈与队列 --Day01
    写在前面2023届秋招形势严峻,作为2024届本科生倍感压力。时间紧迫,需要加快脚步。计划之一是在未来的36天时间里通关Leetcode的剑指offer系列算法题。这一系列的学习周期为......
  • JAVA-类的定义
    packagecom.itheima;publicclassphone{//成员变量Stringbrang;intprice;publicvoidcall(){System.out.println("打电话");......
  • Java 内存泄漏了,怎么排查?
     报警信息显示探测的几个接口有超时情况,多数执行栈都在:java.io.BufferedReader.readLine(BufferedReader.java:371)java.io.BufferedReader.readLine(BufferReader.java......
  • java——注释与空行
                        Java注释:单行、多行和文档注释                      ......