封装和参数调用（格式修改）

封装：把一类事物的特性抽象出来，比如方法和属性，并用代码包装起来，以结果为导向，忽略具体实现过程，即为封装。

思路：

1.封装类

class 类名{

               成员属性定义；

               构造函数（或构造器）；

               成员方法定义并输出；

              }

 

2.加载类对象，初始化属性

TestClass   类名{

                        初始化对象并赋值；

                        再调用；

                       }

代码举例：

public class Teacher1{
    private String name;
    private int age;
    private char gender;
    private String majorField;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age<0 || age>100){
        this.age=30;
        System.out.println("年龄应该在0到100之间，默认为30");
    }else{
        this.age=age;
    }
}
public char getGender(){
    return gender;
}
public void setGender(char gender){
    this.gender=gender;
}
public String getMajorField(){
    return majorField;
}
public void setMajorField(String majorField){
    this.majorField=majorField;
}
public Teacher1(){
    name="李丽";
    age=25;
    gender='女';
    majorField=".NET";
}
public Teacher1(int a,char g){
    age=a;
    gender=g;
}
public void print(){
    System.out.println("我是"+name+",我的年纪是"+age+"岁，我的性别是"+gender+"，我的专业研究ß"+majorField);
}
}
public class TestPeople{
    public static void main(String args[]){
    People p1=new People("Lili",20,'woman',55,165);
    p1.speak();
    String temp=p1.info();
    System.out.println(temp);
        }
}

public class Test9{
    public static void main(String[] args) {
        Teacher1 t1=new Teacher1();

        //为属性赋值用setXXX()方法
        t1.setName("戚薇");
        t1.setAge(200);
        t1.setGender('女');
        t1.setMajorField(".Net");

        //取属性的值用getXXX()方法
        System.out.println("我的名字叫"+t1.getName());
        t1.print();
    }
}

/*

运行结果:

年龄应该在0到100之间，默认为30

我的名字叫戚薇

我是戚薇,我的年纪是30岁，我的性别是女，我的专业研究ß.Net

*/

class A{
	int a;
	int b;
}

public class TestParam{
	public void exchange(int x,int y){
	System.out.println("交换前：x="+x+",y="+y);
	int temp=x;
	       x=y;
	       y=temp;
	       System.out.println("交换后：x="+x+",y"+y);
	}

	public void exchange(A a){
	System.out.println("交换前：x="+x+",y="+y);
	int temp=a.a;          
                      //a.a是什么意思？??任意一个变量，引用数据类型的一种写法
	     a.a=a.b;
	     a.b=temp;
	     System.out.println("交换后：x="+x+",y="+y);
	}

	public static void main(String[] args){
	A a=new A();
	a.a=1;
	a.b=2;
	TestParam tp=new TestParam();
	int x=5;
	int y=10;
	System.out.println("在main()方法中，交换前：x="+x+",y="+y);
	tp.exchange(x,y);
	System.out.println("在main()方法中，交换后：x="+x+",y="+y);

	System.out.println("

在main()方法中，交换前a.a="+a.a+",a.b="+a.b);
	tp.exchange(a);
	System.out.println("在main()方法中，交换前：a.a="+a.a+",a.b="+a.b);
	}
}

　　

/*

运行结果：

在main()方法中，交换前:x=5,y=10

交换前:x=5,y=10

交换后:x=10,y=5

 

 

在main()方法中，交换前：a.a=1,a.b=2

交换前：a.a=1,a.b=2

交换后：a.a=2,a.b=1

在main()方法中，交换后：a.a=2,a.b=1

*/

理解：

主要是基本数据类型和引用数据类型之间的区别；

1.exchange（int x, int y）是值传递，main方法中x、y传递给它时，交换仍然按交换处理，但main方法中的x、y,没有发生变化，只是相当于一个中间变量，自身并不发生变化。（值的拷贝）

2.exchage(A a)是引用传递，也可以理解为地址传递，传递是对象a的地址值，回到main方法中仍然处于交换状态。（方法还是不能让引用类型参数指向新的对象，即交换）

 

方法的可变参数

方法重载的一种特殊情况：需要定义一组方法，这组方法有相同的类型的参数，但参数个数却不同。

例如，需要创建一个计算一组整数和的方法

可变参数的示例：

public class VarArgs {

    public static void main(String[] args) {

        System.out.println(sum(1, 2));

        System.out.println(sum(1, 2, 3));

    }

 

    /**

     * 变长参数求和

     * <a href="http://home.cnblogs.com/u/309701/" target="_blank">@param</a> args

     * @return

     */

    public static int sum(int... args) {

        int n = 0;

        for (int arg : args) {

            n += arg;

        }

        return n;

    }

}