[2013-12-01]JAVA笔记_封装性、对象、引用数据类型、new关键字

1. 使用“private”关键字封装。

·封装属性： private 数据类型 属性名称 = 默认值;

·封装方法： private 返回值类型|void 方法名称（参数列表）

2. 只要是属性就必须封装，被封装的属性通过setter 及 getter方法设置和取得，例如：name属性，setter：setName（）， getter； getName();

`方法名首字母小写。

·取得属性用getter(); 设置属性用setter();

3. 在访问本类中其他方法的时候，为了保证此方法时本类中定义的，可以在方法前面加上 this 关键字：

this.方法() -> 调用本类方法

例子：

//创建一个类
class Person{
private String name;			//私有属性，外部不可以访问
private int age;				//私有属性，外部不可以访问
public void tell(){		//定义说话的方法
//	System.out.println("My name is:" + name + "，My age is:" + age);		//参数之间用加号
//	System.out.println("My name is:" + getName() + "，My age is:" + getAge());
//	有的时候为了明确表明此方法是在类中定义的，会在方法前面加一个关键字this
System.out.println("My name is:" + this.getName() + this.getAge());
}
//定义方法时外部可以间接访问
public void setName(String n){			//方法的首字母小写
name = n;
}
public void setAge(int a){			//定义setter方法的作用
if(a >= 0 && a <= 200){
age = a;
}else{
System.out.println("年龄小于0！！！");
};
}
public String getName(){
return name;
}
public int getAge(){			//方法的首字母小写
return age;
}

};

//封装
public class OODemo07{			//主类
public static void main(String args[]){
Person per = new Person();
per.setName("Jerry");
per.setAge(30);			//age可以是随便的数字所以无法知道是否有效
per.tell();
}
};

4.  关于类、对象

             如果一个类包含了属性和方法，那么该类的每一个对象都具有自己的属性，但无论一个类有多少个对象，这些对象共享同一个方法。

public class ReferenceTest
{
int a = 4;

public static void main(String[] args)
{

ReferenceTest rt = new ReferenceTest();

ReferenceTest rt1 = new ReferenceTest();	//new 出来的新的对象拥有自己独立一份ReferenceTest类的属性，共享ReferenceTest中的方法

ReferenceTest rt2 = new ReferenceTest();

rt1.a = 5;	// 只改变a1保存的对象的地址的属性

rt2.a = 6;	// 只改变a2保存的对象的地址的属性

System.out.println(rt.a);	// 4

System.out.println(rt1.a);	// 5

System.out.println(rt2.a);	// 6

}
}

5. 什么是引用类型(reference type)：引用类型是用在对象上的。一个对象可以被多个引用所指向，但同一时刻，每个引用只能指向唯一的一个对象，如果一个对象被多个引用所指向，那么无论那个引用对对象的属性进行了修改，都会反应到其他的引用当中。

public class Person{		//定义Person类型

int age = 20;

public void change(Person person){	//change方法接受一个person类型变量
person = new Person();
person.age = 30;
}

public static void main(String []args){
Person person = new Person();	//将new出来的对象赋值给person引用数据类型

int age = person.age;

System.out.println(age);	//Boolean默认值是false

person.change(person);

int age2 = person.age;

System.out.println(age2);
}
}

对象：new Person() 这个new出来的东西就是对象。而person是引用数据类型，用来保存生成对象时返回的地址。

引用数据类型：person是一个引用数据类型，里面存放的是对象的地址。

例1：java的参数传递

public class ParamTest{
public static void main(String args[]){

Person person = new Person();//返回地址，保存到引用数据类型person变量中

person.change(person);//传person保存的地址

int age = person.age;

System.out.println(age);

System.out.prinlnt("++++++++++++++++++++");

int i = 10;

person.change2(i);/将10这个实参的值传递过去，形参的改变对i的值没有影响

System.out.println(i);
}
};

class Person{
int age = 20;
public void change(Person person){
person = new Person();
person.age = 30;
}

public void change2(int age){//形参的改变作用域仅在此方法域内有效
age = 40;
}
}

例2： java 参数传递，重要

public class ParamTest
{
public void changePoint(Point point)	//将实参point0X001赋值给形参，此时的point还是0X001
{
point = new Point();		//到此步骤后，将新的对象地址0X002赋给了形参

point.x = 3;		//此时的point存放的是0X002，操作的也是new Point()的新对象自己拥有的属性
point.y = 4;
}

public static void main(String[] args)
{
ParamTest pt = new ParamTest();
Point point = new Point();

pt.changePoint(point);		// 传递实参0X001

System.out.println(point.x);
System.out.println(point.y);
}
}

class Point
{
int x; //横坐标
int y; //纵坐标
}

Java方法参数传递总结：对于 java 中的方法参数传递，无论传递的是原生数据类型还是引用数据类型，统一是传值（pass by value）。对于引用数据类型保存的是对象的地址，在方法传递的时候也是把引用数据类型的值(地址)传递过去。

6. new 关键字在生产对象时按顺序完成了三件事情：

a) 为对象开辟内存空间。

b) 调用类的构造方法。

c) 将生成的对象的地址返回。

7.  声明类类型的类成员变量

     在一个类中可以声明一个引用类型的成员变量。作用：可以通过本类中的引用类型访问所引用类型所声明的类中的属性或方法。

例如：

//伪代码
class Person{
String name;

Book book;	//声明Book类型变量book指向Book类

Person per = new Person();
per.book.getBook();		//操作Book类中的数据
}

class Book{
public String title;

public String getBook(Book book){
this.title = book;
}
}

范例：



在Node类中声明一个Note2类型的变量next1，那么next1存储的是Node2类的引用，指向Node2这个类。将所有类实例化后，可以使用对象。的方式操作数据，所以可以通过next1访问Node2类中的成员变量next2，因为next2又是Node3类的引用，所以可以通过next2访问Node3中的成员变量。（实际上next1 存储的就是 Node对象的引用，next1就是Node2对象，所以可以使用
next1.data这种方式操纵Node2对象中的数据。因为 next1 就是  Node2 对象）
 例如：Node.next1.next2.name;           //可以操纵Node3 类中的属性name或方法。