道招

Java基础第八讲：面向对象基础（二）

如果您发现本文排版有问题，可以先点击下面的链接切换至老版进行查看！！！

Java基础第八讲：面向对象基础（二）

本讲内容：成员变量、方法、方法的重载、构造函数 一、用程序讲解小白的故事 小白是一条狗，它心情好的时候会恭喜人发财，它心情差的时候会对路人撒野，吓得路人落荒而逃。下面我们用面向对象的方式用程序讲述一下小白的故事。
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基础第九讲：面向对象基础（三）

相关文章

Java基础第九讲：面向对象基础（三）

本讲内容：继承、变量隐藏、方法重写、包、修饰符、this、super 一、继承 1、继承的概念 继承是面向对象的三大特性之一。在语义上继承的意思是照法律或遵照遗嘱接受死者的财 阅读更多…

Java基础第十二讲：面向对象基础（六）

本讲内容：内部类 Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。我们内部类的知识在Android手机开发中 阅读更多…

Java基础第十一讲：面向对象基础（五）

本讲内容：接口 一、为什么要有接口 我们已经知道Java中只支持单继承，或者说不允许多重继承的出现，又可以说一个类只能有一个父类。为了提供类似多重继承的功能，Java提供了接口的 阅读更多…

Java基础第十讲：面向对象基础（四）

本讲内容：抽象类、初始化块 一、抽象类 用 abstract 修饰的类定义，我们称之为抽象类，抽象类不能被实例化。 用 abstract 修饰的方法，我们称之为抽象方法，抽象方法 阅读更多…

Java基础第七讲：面向对象基础（一）

本讲内容：面向对象的概念和发展、面向对象的特征 一、面向对象（Object Oriented）编程语言的历史 1950年有个叫做荷兰德的学生作为程序员进入IBM的时候，这个世界上的程序 阅读更多…

关注道招网公众帐号
友情链接
消息推送
道招网关注互联网，分享IT资讯，前沿科技、编程技术，是否允许文章更新后推送通知消息。
允许
不用了