道招

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基础第十一讲:面向对象基础(五)

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

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

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

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

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

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

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

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

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

关注道招网公众帐号
道招开发者二群