55_Java_面向对象1_属性_方法

一、Java面向对象学习的三条主线：
 1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 2.面向对象的三大特征：封装性(Encapsulation)、继承性(Inheritance)、多态性(Polymorphism)、(抽象性)
 3.其它关键字：this、super、static、final、abstract、interface、package、import等

设计类，其实就是设计类的成员
  属性 = 成员变量 = field = 域、字段
  方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
   1.创建类，设计类的成员
   2.创建类的对象
   3.通过“对象.属性”或“对象.方法”调用对象的结构

类中方法的声明和使用
方法的声明：权限修饰符  返回值类型  方法名(形参列表){
                     方法体
               }
Details：
  1  4种权限修饰符：private (私有)、public(默认)、缺省、protected 
  2  返回值类型： 有返回值  vs 没有返回值
         有返回值，指定返回值的类型。使用return关键字来返回指定返回值
        没有返回值，使用void来表示。
  3  形参列表： 方法可以声明0个，1个，或多个形参   格式：数据类型1 形参1, 数据类型2 形参2,...

  4 方法体：方法功能的体现。          
  5.return关键字的使用：
    范围：使用在方法体中
    作用：1 结束方法  2 返回数据
    
 6. 方法的使用中，可以调用当前类的属性或方法 特殊的：方法A中又调用了方法A:递归方法
 7 类中属性(成员变量) PK  成员变量 不同点：
    1 位置的不同
        属性：直接定义在类的一对{}内
        局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
     2 关于权限修饰符的不同
        属性：可以在声明，使用权限修饰符 private、public、缺省、protected  --->封装性
          局部变量：不可以使用权限修饰符。

    3 默认初始化值的情况：
         属性：类的属性，根据其类型，都有默认初始化值。
             整型（byte、short、int、long）：0
              浮点型（float、double）：0.0
             字符型（char）：0  （或'\u0000'）
             布尔型（boolean）：false
              引用数据类型（类、数组、接口）：null

         局部变量：没有默认初始化值 一定要显式赋值
    4 在内存中加载的位置：
         属性：加载到堆空间中   （非static）
         局部变量：加载到栈空间

public class ObjectsTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(20);
        p1.setName("alex");
        p1.setInfo("China");
        p1.show();

    }
}


class  Person {
    String name;
    int age;
    String info;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    // 局部变量必须赋值
    public void show(){
        String hometown ="Shenyang";
        System.out.println(this.name  + this.info + hometown);
    }
}

方法的重载（overload） 
 
1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

 "两同一不同":
 同一个类、相同方法名
 参数列表不同：参数个数不同，参数类型不同
 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

2 可变个数形参的方法
具体使用：
 可变个数形参的格式：数据类型 ... 变量名
 形参类型也相同的数组之间不构成重载 二者不能共存。
 必须声明在末尾
 最多只能声明一个可变形参

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

        OverloadArgsTest o1 = new OverloadArgsTest();
//        o1.show(new int[]{1,2,3});
        o1.show(1,2,3);  // 比 int[] args 调用简单

    }

    // 方法重载

    public void getSum(int i,int j){
        System.out.println("1");
    }

    public void getSum(String s ,int i){
        System.out.println("3");
    }

    // 可变形参
    public void show(String s){
        System.out.println("show(String)");
    }
    public void show(int... i){
        System.out.println("show(String...)");
    }

//    public void show(int[] args){    // 无法与 show(String... s) 共存
//        System.out.println("show(String[] args)");
//    }
}

关于变量的赋值：
 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

public class ValueTransferTest2 {
	public static void main(String[] args) {
		
		Data data = new Data();
		data.m = 10;
		data.n = 20;
		
		System.out.println("m = " + data.m + ", n = " + data.n);
		
		//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;
		
		ValueTransferTest2 test = new ValueTransferTest2();
		test.swap(data);	
		System.out.println("m = " + data.m + ", n = " + data.n);
	}
	
	public void swap(Data data){
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
}

class Data{
	int m;
	int n;
	
}

递归方法的使用
 1.递归方法：一个方法体内调用它自身。
 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

public class RecursionTest {

	public static void main(String[] args) {

	// 例1：计算1-n之间所有自然数的和
	public int getSum(int n) {// 3
		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}
	}

	// 例2：计算1-n之间所有自然数的乘积:n!
	public int getSum1(int n) {
		if (n == 1) {
			return 1;
		} else {
			return n * getSum1(n - 1);
		}
	}