Java入门系列教程#3 变量、方法、修饰符
本文最后更新于 308 天前,其中的信息可能已经有所发展或是发生改变。

上一期我们了解了Java的基本语法,本期开始我们来对上一期中提到的各种概念进行补充,先来看一看变量与方法。

本期教程对于初学者来说,新出现的名词和概念很多,需要反复理解、实践,一次看不懂,那就多来几次。
内容很多,在看的同时也一定要自己多动手操作,初学者易犯的错误就是完全跟着教程走而没有自己的思考和想法,连类名、方法名、变量名都起得和教程完全一致,这样的学习效果很差。建议在看完一个小节后自己也试着多写几次,而不是单凭记忆学习。
建议本节内容与下一节一起学习。

学习内容

  1. 变量的声明
  2. 方法的声明
  3. 熟记所有基本数据类型
  4. 两种常用修饰符的使用

准备工作

在开始之前,请先新建一个类或使用现有的类完成下面的操作。

还是先在里面写上main函数供我们执行代码。

class后接类名,例如class Funcs

[访问修饰符] [非访问修饰符] [返回值类型]后接方法名,例如public void name() {} private int name2() {}

修饰符

注意:以下例子只会涉及到本类和外部类,日后遇到了外部类,将不再解释为什么不能通过 对象.方法名对象.变量名来访问这个对象的private或protected方法,因为这样就已经是在外面类调用方法或变量了。

访问修饰符

default默认修饰符

不加任何访问修饰符即代表使用默认修饰,例如:

int defaultInt = 101;  
void defaultMethod() { 
                       
}   

这是一个没有任何访问修饰符的方法和变量,它们对同一个包内的类可见。

public公有修饰符

被public修饰的类、方法、变量、接口可以被任何类访问,例如public static void main(String[] args) {}只有被public修饰,它才能被Java解释器访问执行。

int publicMethod = 11;             
public void publicMethod() {       
                                   
}     

private私有修饰符

private是最严格的修饰符,被它修饰的类、变量、方法只能在本类内访问。

int publicMethod = 11;                    
public void publicMethod() {              
    privateMethod();                      
}                                         
                                          
int privateMethod = 123;                  
public void privateMethod() {             
                                          
}     

如上所示,本类内的public方法可以访问本类内的private方法,变量也是如此。

注意:private不能修饰类和接口

protected受保护的修饰符

还记得吗?类的里面可以继续镶套类。因此我们用两个不同的类来演示,这里的内容超前了一些,涉及到类的声明,但不用担心,目前我们只需要了解protected修饰符的作用即可。

int publicMethod = 11;                    
public void publicMethod() {              
    privateMethod();                      
}                                         
                                          
int privateMethod = 123;                  
public void privateMethod() {             
                                          
}     

像这样我们就在InnerClassB的methodB方法内声明了InnerClassA并命名为classA,现在我们可以通过classA.方法名classA.变量名 来访问里面的方法或变量。

注意:像这样对类里面的方法或变量进行访问/获取,实际上是在对实例变量/方法做出操作。若要访问类的静态变量,直接使用InnerClassA.静态变量命/方法名即可。(后续还会再讲)

现在我们试着来看看我们访问classA内的哪些东西:

你会惊奇地发现,InnerClassB居然可以访问innerClassA的private变量,这是不是和上面说的不太一样呢?

其实并不是,因为A和B这两个类都是在同一个类Funcs下的,因此innerClassA里面的变量/方法的访问权限还是作用在Funcs并非innerClassA。

非访问修饰符

看完了访问修饰符,再来看看下面的非访问修饰符。

非访问修饰符有5种,这里先介绍其中两种常用的static和final。

static静态修饰符

  • 静态变量:static 修饰符可以用来声明独立于对象的静态变量,无论一个类被$实例化$多少次,这个变量依然存在并且不发生改变。
  • 静态方法:static修饰符还可以用来声明独立于对象的静态方法。静态方法只能只用静态变量与静态方法。

这里我们继续拿上面的protected修饰符用到的类举例:

static class InnerClassA {                      
    protected int protectedInt = 233;           
    public int publicInt = 123;                 
    private int privateInt = 456;               
                                                
    public static int staticInt = 0;            
    public static void add() {                  
        staticInt = staticInt + 1;              
    }                                           
}                                               
                                                
class InnerClassB {                             
    public void methodB() {                     
        InnerClassA classA = new InnerClassA(); 
                                                
    }                                           
}          

我们声明了一个变量和一个方法,它们都是静态的,因此我们在classB中用classA.add()调用A类的方法是不行的。现在我们必须用类名.变量名/方法名来调用类的静态变量.方法。

final修饰符

final就很简单了,就三种用途:常量、方法、类

  • final变量一旦赋值后,不能被重新赋值。
  • 父类中的 final 方法可以被子类继承,但是不能被子类重写。
  • final 类不能被继承。

只要知道final以上三个特性即可。


变量

上期提到变量有三种:局部变量、类变量、实例变量,下面我们跟着例子来详细了解它们的声明与使用。

基本数据类型

Java中有8种基本数据类型:byte(字节)、int(32位整数)、long(64位长整数)、char(Unicode字符)、short(16位整数)、boolean(逻辑,只有true和false两个值)、float(32位单精度浮点数)、double(64位双精度浮点数)。

务必要熟记上面的八种数据类型以及它们对应的意义

在学习变量的同时,也将常用的数据类型嵌入其中一起学习。

局部变量

局部变量就是类的方法中的变量,它们没有初始值,需要手动赋予。

public void method() { 
    int abc = 10;      
    int abcdefg = 16;  
    float f1 = 1.51f;  
    double d1 = 2.333d;
}      

像这样,我们在method这个方法里面定义了4个变量。

int是变量的数据类型,abc、abcdefg、f1、d1 是变量名,单个 = 是赋值符号,10、16、1.51f、2.333d是欲赋予的值,分号就是一句代码的句号。

注意:局部变量不可以被修饰符修饰,如public、private、static等(final例外)

实例变量

实例变量声明在类中,但不在方法、代码块内,它们与类同生共死,在类被创建之后,它们的值才被确定,但你可以提前为它们指定一个默认值,这样类被创建之后就会自动给它们赋予默认值。

public class Funcs {                                   
    public int abc = 1;                                
    public int abcdefg = 233;                          
    public char add = '\u0000';                        
    public byte b = 127; // Byte的最大值                   
                                                       
    public void method() {                             
        int abc = 10;                                  
        int abcdefg = 16;                              
        float f1 = 1.51f;                              
        double d1 = 2.333d;                            
    }                                                  
} 

观察一下,实例变量是声明在类下面的变量,并且可以与局部变量同名。这样的变量可以供本类内访问。

这里我们又认识了两个新数据类型:

  • char可以表示任何Unicode字符,并且只能通过单引号赋值。
  • byte表示一个字节,一个字节的长度是8位,但byte类型的第一位用来表示正负,故实际上只有7位数,2的7次方是128,但是byte不能表示128,因为128刚好是10000000超过了7位。

类变量(静态变量)

类变量也称静态变量,声明时常与final一起连用,静态变量在第一次被访问时创建,在程序结束时销毁,并且不管这个类被$实例化$几次,静态变量的值也不会改变。

public class Funcs {                              
    public static boolean bool = true;            
    public static final String STR = "This is a text."; 
                                                  
    public int abc = 1;                           
    public int abcdefg = 233;                     
    public char add = '\u0000';                   
    public byte b = 127; // Byte的最大值              
                                                  
    public void method() {                        
        int abc = 10;                             
        int abcdefg = 16;                         
        float f1 = 1.51f;                         
        double d1 = 2.333d;                       
    }                                             
}             
注意:若要声明常量,命名时最好大写所有字母,用下划线代替空格,例如STR、STR_2

常量

直接在访问修饰符后面加上final即可将变量变为一个常量,例如:

final int a = 1;

public final float b = 2.0f;

public static final double c = 3.0d;

再次回顾一下变量的声明,这里的a、b、c是变量名,int、float、double是变量的数据类型,而在数据类型前的就是修饰符。


方法

为什么要用方法?

例如现在我们定义一个新运算AOB,把整数A与整数B相加再乘2得到结果,很显然我们可以直接用两个变量实现。但是如果我们要在100个地方使用这个运算,那是不是要声明200个变量呢?很显然这种方法是低效的,因此我们需要一个固定的模板来简化操作。

语法

[访问修饰符] [非访问修饰符] [返回值类型] [方法名] ([参数类型 参数名称]...) {}

void代表无返回值

例如:

public void method1() {} 访问修饰符 返回值类型 方法名

public static void method() {} 访问修饰符 非访问修饰符 返回值类型 方法名

public int getId() { ... } 访问修饰符 返回值类型[整数] 方法名

参数

在实际运用中,我们可能需要参数,参数的声明很简单,在()内声明,只要仿照下面即可。

(int a) 单个参数

(int a, float b) 两个参数

(int a, int b, double c) 三个参数

如上,如果要添加多个参数,只需要像声明变量一样,分号用逗号代替即可。

注意:Java不支持函数参数默认值。

返回值与return

一个新的名词:函数的返回值

在上一期就已经初步认识了方法(函数),这里我们只需要知道怎么让函数返回一个值。

要让函数返回一个值,需要用到return 返回值;

例如:

public int getId() { return 100; }

若函数的返回值类型是void,则可以省略return,若不是,则必须含有return。
return还有一个作用就是阻断代码运行,当执行到return时,代码就不会继续往下执行了,要注意的是,若一个方法的return被其他代码块如if、for、switch等包裹,则在这个方法的下一级必须要有一个return。同样return不能直接放在代码中间,这样下面的代码就会变得无意义。

调用方法

在同类里面可以直接通过方法名(参数)来调用方法,外部类就用变量名/类名.方法(参数)调用。

只有在方法被static修饰时才可以用类名.方法(参数)直接调用
static class InnerClassA {
    protected int protectedInt = 233;
    public int publicInt = 123;
    private int privateInt = 456;
    
    public static int staticInt = 0;
    public static void add() {
        staticInt = staticInt + 1;
    }
    
    public void submit(int code) {
       add();
    }
}
class InnerClassB {
    public void methodB() {
        InnerClassA classA = new InnerClassA();
        classA.submit(404);
    }
    public int methodB2(int a, int b) {
        return (a + b) * 2;
    }
}

上述代码中的add();classA.submit(404);就是本类和外部类的调用。

在InnerClassB的methodB中,InnerClassA被实例化并且赋值到了classA变量上,因此我们要访问新实例化出来的类的方法或变量,就必须用class.方法名class.变量名来访问。

举例实现

现在我们通过一个简单的例子,结合上面所需的知识,来完成上面举例的新定义的运算吧:

public int methodB2(int a, int b) {      
    return (a + b) * 2;                  
}       

这样我们就完成了一个带有参数的函数。

补充

看到这里你可能还不明白类到底有什么用,为什么要实例化类,下一期的内容就是类与对象,这里先简单说明一下。

类就好像是计算机里已经编辑好的一张Word表单,实例化就是把它打印出来;实例变量就是在里面要填写的内容,比如姓名、年龄,给实例变量赋值就是打印出来它们就已经填好了的,但是你仍可以擦掉它们重写;而方法就是其他内容,这个整体是固定的不可改变。

因此,我们如果想要自己对一张表单进行读写,就必须先把它们打印出来,才能实际动手操作它们。

而通过变量名/类名加上一个小圆点来访问实例变量/方法,就相当于是指定了你要操作的那张表单,防止混淆要操作的对象。

也就是说,类是一个模板,可以被实例化无数次,每个实例化出来的都相对独立,也就相当于打印了好几份表单,你可以为不同表单填写不同内容。

总结

本期的内容有很多,首先八种基本数据类型要熟记,其次就是掌握变量和方法的声明,以及三种访问修饰符、两种非访问修饰符的使用。其实这些内容都只需要会用就行了,用法很容易掌握,多用几次多试几次就能领悟到。先把用法搞清楚,之后再回来了解概念就很轻松。

课后练习

  1. 基本数据类型有哪些?实例变量与局部变量的区别是什么?
  2. 若方法返回值为空,则返回值类型应该是什么?
  3. 有哪些修饰符,它们的区别是什么?
未经允许禁止转载本站内容,经允许转载后请严格遵守CC-BY-NC-ND知识共享协议4.0,代码部分则采用GPL v3.0协议
暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇