本讲内容:成员变量、方法、方法的重载、构造函数

一、用程序讲解小白的故事

小白是一条狗,它心情好的时候会恭喜人发财,它心情差的时候会对路人撒野,吓得路人落荒而逃。下面我们用面向对象的方式用程序讲述一下小白的故事。

01 public class Dog {
02
03     //构造函数
04     public Dog(){
05         size =3;
06     }
07
08     //定义叫声常量
09     final String BARK_NORMAL = "汪!汪汪!";
10     final String BARK_HAPPY = "旺!旺旺!";
11     final String BARK_SAD = "呜……嗷!";
12
13     //定义心情常量
14     static final int NORMAL =0;
15     static final int HAPPY =1;
16     static final int SAD = 2;  
17
18     // 定义了狗的个头大小的属性
19     private int size;
20
21     // 定义获取个头的方法
22     public int getSize() {
23         return size;
24     }
25
26     // 定义狗叫的方法
27     public void bark(){
28         if(size<5){
29             System.out.println("汪汪汪!");
30         }else{
31             System.out.println("嗷!嗷!");
32         }
33     }
34
35     //定义狗叫的方法,带心情参数
36     public void bark(int mood){
37         switch(mood){
38         case NORMAL:
39             System.out.println(BARK_NORMAL);
40             break;
41         case HAPPY:
42             System.out.println(BARK_HAPPY);
43             break;
44         case SAD:
45             System.out.println(BARK_SAD);
46             break;
47         }
48     }
49
50     //定义main方法
51     public static void main(String[] args) {
52         //创建了名字叫小白的狗对象
53         Dog xiaoBai = new Dog();
54         //调用它叫的方法
55         xiaoBai.bark();
56
57         //调用带参数的方法
58         xiaoBai.bark(HAPPY);
59     }
60
61 }

运行程序,看一下输出结果:

image

二、类定义中的五个顶级成员(top-level member)

实体 static修饰 没用static修饰
成员变量 类变量 实例变量
初始化块 静态初始化块 实例初始化块
构造方法 / 构造方法
方法 类方法 实例方法
接口 嵌套的接口 member interface /
嵌套顶层类 nested top-level class 内部成员类 inner member class

 

三、成员变量(类或对象的状态)

1、认识成员变量(类或对象的状态)、类变量、实例变量、局部变量、方法参数之间的区别

成员变量(field)是没有定义在代码块(包括初始化块、成员方法)中的变量。成员变量是类变量还是实例变量取决于在其声明中是否使用了static关键字。

类变量在声明是用了static关键字,它的另一个名字叫静态变量、静态成员变量(static field) 。

实例变量是在声明时没有使用static关键字的成员变量,它的另一个名字叫非静态成员变量(non-static field)。

定义在代码块里的变量被称为局部变量(local variable)。

定义在方法声明中的变量叫方法参数

01 public class Lesson08 {
02
03     // 类变量
04     static String s1 = "类变量";
05
06     // 实例变量
07     String s2 = "实例变量";
08
09     // 初始化代码块里的局部变量
10     {
11         String s3 = "初始化代码块里的局部变量";
12         System.out.println(s3);
13     }
14
15     // 静态初始化代码块里的局部变量
16     static {
17         String s4 = "静态初始化代码块里的局部变量";
18         System.out.println(s4);
19     }
20
21     // 方法的参数和方法里的局部变量
22     public void printString(String s5) {
23         String s6 = "方法里的局部变量";
24         System.out.println("方法的参数:"+s5);
25         System.out.println(s6);
26     }
27
28     // 类方法
29     public static void printString() {
30         String s7="类方法里的局部变量";
31         System.out.println(s7);
32     }
33
34     // main方法
35     public static void main(String[] args) {
36
37         //调用类方法
38         Lesson08.printString();
39
40         //打印类变量
41         System.out.println(s1);
42
43         //创建对象
44         Lesson08 lesson = new Lesson08();
45
46         //打印实例变量
47         System.out.println(lesson.s2);
48
49         //调用实例方法
50         lesson.printString("参数的值");
51
52     }
53
54 }

对于他们之间的区别,我们在以后的学习中你会越来越清晰的。

2、变量的初始化

实例变量一经定义就会有初始值,局部变量定义时不赋初值而直接使用,编译器会报错

01 public class Lesson08_1 {
02
03     int i;
04     static int j;
05     {
06         int k;
07         System.out.println(k);
08     }
09
10     static {
11         int l;
12         System.out.println(l);
13     }
14
15     public void print(String m){
16
17         System.out.println(m);
18     }
19
20     // main方法
21     public static void main(String[] args) {
22         int n;
23         System.out.println(n);
24
25         Lesson08_1 lesson =new Lesson08_1();
26         lesson.print("m");
27     }
28
29 }

运行程序,查看结果:

image

然后我们再给局部变量都附上初值,再把实例变量和类变量都打印出来看看,代码如下:

01 public class Lesson08_1 {
02
03     int i;
04     static int j;
05
06     {
07         int k=2;
08         System.out.println(k);
09     }
10
11     static {
12         int l=2;
13         System.out.println(l);
14     }
15
16     public void print(String m){
17
18         System.out.println(m);
19     }
20
21     // main方法
22     public static void main(String[] args) {   
23
24         System.out.println(j);
25
26         int n=2;
27         System.out.println(n);
28
29         Lesson08_1 lesson =new Lesson08_1();
30         lesson.print("m");
31         System.out.println(lesson.i);
32     }
33
34 }

运行程序,查看结果:

image

我们看到类变量和实例变量没赋值照样有值打印出来,我们也看到int的初始值是0 。

实例变量和类变量的类型 初始值
整数 0
浮点类型 0.0
字符类型 ‘/u0000′
布尔类型 boolean false
引用数据类型(譬如数组、接口、类) null

 

四、方法(类或对象的行为)

 

1、方法

Java中类的行为由类的成员方法来实现。类的成员方法由方法的声明和方法体两部分组成。

image

修饰符,可选,用于指定谁有权限访问此方法。

返回值类型,必选,用于指定该方法的返回值数据类型;如果该方法没有返回值,则要用关键字 void 进行标示。方法的返回值只能有一个。

参数列表,可以有0到多个,多个参数之间要用逗号隔开,参数的写法形如:String[] args, int age 这样。

方法名,必选,这个……,好吧命名规则是方法名和变量名的首字母要小写,别丢我人,弄个大写方法名出来。

方法体,可选,这个……,

大括号,大括号不写的方法叫抽象方法。

2、属性和方法之间的关系

有句绕口令是这么说的:“状态影响行为,行为影响状态”。你有没有想过这问题,如果每个对象都是从同一个类中生 成出来,每个对象如果都一摸一样,那么这个世界是不是太无趣了。好在,我们看到前面的例子中,小狗的大小属性影响了他叫的方式。通过设置狗大小的方法又改 变了它的状态。这些属性和方法的细节上的不同导致了,多姿多彩的对象,我们后面还会讲到更多的技术,也会导致更多的多样性。

五、方法重载 overload

Java里可以提供同一个方法的多个不同参数的版本供我们调用,譬如上面的小白,它叫 bark() 的方法有两种,一种是很随意的叫,无拘无束的叫,还有一种是根据它心情的不同来叫,当然我还可以再定义一个方法可以让他根据主人的脸色来叫,我们也可以再 定义一个方法,穿的参数是食物,那么它的叫声可能就是边吃边幸福的吼叫了…… 这样一个bark方法就带来了丰富多彩的变化。

在Java 中允许类定义中多个方法的方法名相同,只要它们的参数声明不同即可。这种情况下,该方法就被称为重载(overloaded ),这种方式就叫做方法重载(method overloading )。方法重载是实现程序多样性的一个重要手段。也可以称作多态的一种表现方式。

image

重载规则:

  1. 重载方法必须改变方法参数列表
  2. 重载方法可以改变返回类型
  3. 重载方法可以改变访问修饰符
  4. 重载方法可以声明新的或更广的检验异常
  5. 方法能够在同一个类或者一个子类中被重载
01     public class lesson08_2 {
02
03     static long max(long a,long b){
04         System.out.println("max(long a,long b)");
05         return a>b?a:b;
06     }  
07
08     static long max(long a,int b){
09         System.out.println("max(long a,int b)");
10         return a>b?a:b;
11     }
12
13     static int max(int a,int b){
14         System.out.println("max(int a,int b)");
15         return a>b?a:b;
16     }
17
18     static byte max(byte a,byte b){
19         System.out.println("max(byte a,byte b)");
20         return a>b?a:b;
21     }
22
23     public static void main(String[] args) {
24         byte byte1 = 125;
25         byte byte2 = 126;
26         int int1 = 1;
27         int int2 = 2;
28         long long1 = 1000;
29         long long2 = 2000;
30
31         System.out.println(max(byte1,byte2));
32         System.out.println(max(int1,int2));
33         System.out.println(max(byte1,int2));
34         System.out.println(max(int1,long2));
35         System.out.println(max(long1,int2));
36         System.out.println(max(long1,long2));
37     }
38 }

上面的例子说明了参数声明不同的含义,那就是只要参数的个数,类型和顺序任意一项不同就算不同的参数声明,即使它们看起来很相似,甚至看起来可能会让虚拟机搞混。不过没关系,虚拟机很聪明,只要你按照规则走他就能分清。

六、构造函数

在Java中,对象是构造出来的,特意用了一个new关键字来标示这个创建的过程。

image

我们把上一讲的例子修改一下,看看创建对象的过程发生了什么。

01 public class Dog {
02
03     // 定义了狗的个头大小的属性
04     private int size=3;
05
06     public Dog(int size){
07         System.out.println("带参数的构造函数");
08         this.size = size;
09     }
10
11     public Dog(){
12         System.out.println("不带参数的构造函数");
13         this.size=2;
14     }
15
16     // 定义狗叫的方法
17     public void bark(){
18         if(size<5){
19             System.out.println("汪汪汪!");
20         }else{
21             System.out.println("嗷!嗷!");
22         }
23     }
24
25     //定义main方法
26     public static void main(String[] args) {
27
28         //创建了名字叫小黄的狗对象
29         Dog xiaoHang = new Dog(4);
30
31         //调用它的叫方法
32         xiaoHang.bark();
33
34         //创建了名字叫大黄的狗对象
35         Dog daHang = new Dog(6);
36
37         //调用它的叫方法
38         daHang.bark();
39
40         //创建了名字叫小黑的狗对象
41         Dog xiaoHei = new Dog();
42
43         //调用它的叫方法
44         xiaoHei.bark();
45     }
46 }

我们看到创建对象的过程就是执行构造函数的过程,而且也看到构造方法也可以重载。

我们在这里明确的是说明构造函数或者说构造方法,它不是方法。它们之间的三大区别,为了让你记清楚,我做了个图:

image

关于构造方法,还有一部分非常有趣的内容我们放在继承章节和大家一起分享。

本讲就到这里,各位再见,Take some time and enjoy it 。

分享至上:分享源头

随机文章

Java基础第十讲:面向对象基础(四)
Java基础第十讲:面向对象基础(四)

魔兽世界大脚插件也有时不给力啊
魔兽世界大脚插件也有时不给力啊

浅析angular.forEach
浅析angular.forEach

wordpress上传图片失败解决方案
wordpress上传图片失败解决方案

U盘安装ubuntu linux, 重启后屏幕一直停留在Peter Anvin et al
U盘安装ubuntu linux, 重启后屏幕一直停留在Peter Anvin et al

相关文章

Java基础第十讲:面向对象基础(四)
Java基础第十讲:面向对象基础(四)

Java基础第九讲:面向对象基础(三)
Java基础第九讲:面向对象基础(三)

Java基础第七讲:面向对象基础(一)
Java基础第七讲:面向对象基础(一)

Java基础第十一讲:面向对象基础(五)
Java基础第十一讲:面向对象基础(五)

Java基础第十二讲:面向对象基础(六)
Java基础第十二讲:面向对象基础(六)

起凡被黑?咋做任务的空间几天都打不开啊
起凡被黑?咋做任务的空间几天都打不开啊

内容分享:道招
本文链接:Java基础第八讲:面向对象基础(二)
道招声明:除特别标注或作者不详外,本站所有文章均为原创,转载请注明。欢迎共同关注互联网!