【转载】J2SE知识点归纳笔记(三)---Java面向对象 part 1

注：本文转载自coder-pig   

原文链接：http://blog.youkuaiyun.com/coder_pig/article/details/22262055

文章看了看，写得不错，单看最后实例代码的注释就知道了，不加注释的代码不是好代码哦。马上五一放假了，有点激动哦~~~~~~~~~但是假期不要太懒惰哦，加油加油~

Java面向对象

ps:因为面向对象的内容比较重要,而且很多要通过代码理解的;

如果全部写在一篇文章中会显得篇幅过长,过于累赘;读者读得累;

我也写得累!

前言

在上一节中我们对Java的基础知识进行了学习;

在这一节中我们将会进一步了解Java的核心

面向对象部分!这一节很重要,也是后面几节的基础,

希望大家可以认真学习下！

EveryThing is Object!

面向对象的理解:

对象的引入:

所有事物都具有两个方面:有什么?能干什么

对应的,我们可以理解为

属性:描述对象;

方法:对象有什么功能

对象设计的要求:

高内聚,低耦合,从而提高对象的可复用性

注：这里解释下高内聚低耦合，这句话字面上不好理解。

 耦合性也称块间联系：指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。

 内聚性又称块内联系：指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。

 例子：一个程序有50个函数，这个程序执行得非常好；然而一旦你修改其中一个函数，其他49个函数都需要做修改，这就是高耦合的后果。
一旦你理解了它，你编写概要设计的时候设计类或者模块自然会考虑到“高内聚，低耦合”。

对象设计的思想:

以对象为中心,先开发类,得到对象,再通过对象间的相互通信实现功能

对象

如何创建对象:

new关键字 + 指定类名创建

eg:Person p = new Person();

对象的产生:

现在堆内存中创建一个对象----->然后在栈内存中创建一个变量引用对象的地址

对象与对象的引用:

对象名作为操作的标识符,仅仅只是对象的一个引用而已,而并非对象本身;

有引用,但不表示一定要有一个对象与引用相连;

所以在创建一个引用时,都需要进行初始化

对象的使用:

通过点语法访问.eg:p.age = 18;

对象的生命周期:

从new创建开始,到没有任何引用到达对象时结束(成为垃圾)

匿名对象的使用:

不定义变量引用对象,用new创建后直接调用,没名字,所以叫做匿名对象

通常我们需要使用一对象,且只用一次的话,就用匿名对象(没有引用,使用一次后就变成垃圾了)

可以作为实参进行传递

注：这里给大家举一个匿名类的例子。

有一个方法：mMethod(Person p),该方法的参数是一个对象，你用这个方法的时候有两种方式传参。

方法一：Person p=new Person();

mMethod(p);

方法二：mMethod(new Person());         用一个没有名字的对象作为参数。

类:

类与对象的建模过程:

类的定义:

类的一般形式:

class 类名

{

        成员变量

构造方法

成员方法

}

成员变量与局部变量的区别:

成员变量:定义在类中,在整个类中都可以访问,存在于栈内存的对象中,随着对象的消失而消失,有默认初始值

局部变量:定义在方法,语句,局部代码块中,只在所属区域有效;存在栈内存的方法中,随所属区域的执行而执行;结束而

         释放,没有默认初始值

成员变量的初始化:

当对象创建时,会对成员变量自动赋初值,基本数据位0,引用型为null;

注:char为"\u0000"表空     boolean:false

构造方法(Constructor)

介绍:

为对象进行初始化的一个特殊方法,在生成对象时会被调用来初始化对象

构造方法名需与类名相同,new对象时隐式地进行调用,用户无法显式调用;

无返回值,不能加void返回值类型,总会有的,就算你不写构造方法;

也会自动生成默认缺省的构造方法;当然如果我们写了,就不会再生成了

构造方法的重载(overLoading):

又叫编译时的多态,需要参数类型

方法名相同,参数不同(个数,类型)

this关键字:

1)用于区分局部变量与实例变量

2)显式地调用重载的构造方法,貌似用的不怎么多,就是构造方法的相互调用

调用语句需要写在第一行哦！

eg:

1. /* 
2.  * 该程序演示的是构造方法的重载和this关键字的作用 
3.  * */  
4.   
5. public class Test {  
6.       
7.     private int i;  
8.     private String str;  
9.       
10.     //这个构造方法是完成变量初始化的方法,this在这里区分局部变量与成员变量哦！  
11.     public Test(int i,String str) {  
12.         this.i = i;  
13.         this.str = str;  
14.     }  
15.       
16.     //通过this调用上面的构造方法,要放在第一行  
17.     public Test(String str)  
18.     {  
19.         this(1,"woqu");  
20.     }  
21.       
22.     //通过this调用上面的构造方法,要放在第一行  
23.     public Test()  
24.     {  
25.         this("HeHe");  
26.     }  
27.       
28. }  

成员方法:

一个好的方法应该有好的移植性和可重用性

两种传参方式:

①按值传递:内存的空间变量  eg:int i

②按引用传递(传对象引用):Integer类的一个对象引用: Integer i = new Integer(10);

public修饰类的规则:

一个Java文件,只允许有一个修饰为public的类或者接口,且名字要与文件名相同,不然编译器会报错

包的概念:

打包:package      eg:   package com.jay.example;

导包:import     eg:inport java.io.*;

注意:导包时用星号只表示该层次的所有类,但是不包含子层次下的类！！！！

作用域修饰符:

默认(default):同包可见                                    public共有:所有类可访问

private私有:同一类可见      protected保护:子类或同包可见

ps:要注意private和protected都不能够修饰类啊！！！！

数据成员与方法成员在内存中的组织:

数据成员占据不同的内存区域;所有方法成员共享一段程序代码

知识点使用实例:

步骤:

定义一个Person类,然后再建立一个测试类PersonTest,对相关方法进行调用

代码如下:

Person.java

1. //将该类打包到一个文件夹中  
2. package com.jay.example;  
3.   
4. public class Person {  
5.       
6.     /* 
7.      * 定义成员变量,和成员变量不同,当我们new对象时 
8.      * 系统会给他们生成默认的初始值,这里之所以将所有变量都 
9.      * 设置成private私有,是为了实现封装,外界如果想访问 
10.      * 修改属性的话,需要通过该类提供的get,set方法进行访问 
11.     */  
12.     private String name;  
13.     private int age;  
14.       
15.     /* 
16.      * 这里我们定义的是构造方法,构造方法是用来进行变量初始化的 
17.      * 因为我们自定义了一个有参的构造方法,那么系统就不会再自动生成 
18.      * 无参的缺省构造方法了,但是一个好的编程习惯还是把这个却省的构 
19.      * 造方法写上,this在这里起的作用就是区分局部变量与成员变量 
20.      * */  
21.       
22.     public Person(String name,int age)  
23.     {  
24.         this.name = name;  
25.         this.age = age;  
26.     }  
27.     public Person(){}  
28.       
29.     /* 
30.      * 接着到成员方法的定义了; 
31.      * 我们先定义set和get的方法; 
32.      * 可以理解为通过这个方法为外界提供一个接口 
33.      * 别的类可以通过这个接口访问相关属性的值 
34.      * */  
35.       
36.   
37.     public String getName() {  
38.         return name;  
39.     }  
40.     public void setName(String name) {  
41.         this.name = name;  
42.     }  
43.     public int getAge() {  
44.         return age;  
45.     }  
46.     public void setAge(int age) {  
47.         this.age = age;  
48.     }  
49.       
50.     //定义打印信息的方法  
51.     public void printMsg()  
52.     {  
53.         System.out.printf("姓名: "+name+"\n年龄:  "+age);  
54.     }  
55.       
56. }  

PersonTest.java

1. package com.jay.example;  
2.   
3. public class PersonTest {  
4.     public static void main(String[] args) {  
5.           
6.         String pname = null;  
7.         int page = 0;  
8.           
9.           
10.         //将Person类实例化为对象  
11.         Person p = new Person("小猪",20);  
12.         p.printMsg();  
13.           
14.         //通过get方法获得参数,自己输出  
15.         pname = p.getName();  
16.         page = p.getAge();  
17.         System.out.println("\n姓名: "+pname+"\n年龄:  "+page);  
18.           
19.         //通过set方法设置参数,调用printMsg打印信息  
20.         p.setName("大猪");  
21.         p.setAge(25);  
22.         p.printMsg();  
23.     }  
24. }  

执行效果图:

总结:

在这一小节里面,我们对类与对象进行了初步的解析;

对类与对象的定义,构造方法,作用域等进行了学习

通过案例可以进一步加深大家对类与对象的了解

好了,这一节就到这里了,如果有什么疑问,错误,纰漏,或者

好的建议,望读者指出,不甚感激!(*^__^*) 嘻嘻……