java方法（调用、重载），数组（创建，多维），对象、类的封装、构造方法

今天记点纯知识
（由于学了c++，方法之类的就不写了）

方法

定义一个方法

修饰符 returnValueType 方法名(参数类型 参数名)
{         ...       
         方法体     
          ...      
         return 返回值;  }

修饰符：访问类型
returnValueType ：方法返回值的数 据类型

方法调用：

当方法返回一个值，

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println("这是我的第一个Java程序！"); 

方法重载

最基础的：2个方法—有相同名字但参数不同
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表
Java编译器根据方法签名判断哪个方法应该被调用
方法的重载与返回值类型无关，它只需满足两个条件，一是方法名相 同，二是参数个数或参数类型不相同
参数不同不得不说这样一段代码：

public class TestOverload {
     //方法1
     public static void method(int a){
         System.out.println("执行method(int a)");
      }     
      //方法2     
      public static void method(long a){         
          System.out.println("执行method(long a)");    
      }     
      //方法3     
      public static void method(Integer a) {         
      	System.out.println("执行method(Integer a)");     
      }     
      //方法4    
      public static void method(Object a) {         
      	System.out.println("执行method(Object a)");     
      }     
      //方法5     
      public static void method(int...a) {         
      	System.out.println("执行method(int...a)");     
      }          
      public static void main(String[] args) {         
      	int a = 0;         
      	method(a);     
      } 
    }

如果注释掉方法1,会调用哪个方法呢？大多数人的选择可能是方法3，int 会自动装箱然后调用方法3；但结果调用的是方法2
这里说下int和Integer：Java是面向对象的编程语言，一切都是对象，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换，对应如下：
原始类型：boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
顺便一提，Java中的基本数据类型只有以上8个，除了基本类型（primitive type），剩下的都是引用类型（reference type）。
所以最基本的一点区别是：Ingeter是int的包装类，int的初值为0，Ingeter的初值为null。

数组：

声明数组变量

dataType[] arrayRefVar;   // 首选的方法    
//或    
dataType arrayRefVar[];  // 效果相同，但不是首选方法 

使用new操作符来创建数组

arrayRefVar = new dataType[arraySize]; 

数组变量的声明，和创建数组可以用一条语句完成

dataType[] arrayRefVar = new dataType[arraySize]; 

也可以

dataType[] arrayRefVar = {value0, value1, ..., valuek}; 

处理数组------for-each循环

for(type element: array) {
     System.out.println(element); 
     }

多维数组

数组的数组
定义：

//第一种方式：
int str[][] = new int[3][4]; 
//第二种方式：
int[][] arr = new int[3][]; 
//第三种方式：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; 

面向对象

特性：封装，继承，多态
类是对象的抽象，对象是类的实例。
类中可以定义成员变量和成员方法

public class Person {     int age;     void speak(){         System.out.println("我今年"+age+"岁！");     } } 

注意：在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量 被称为局部变量。如果在一个方法中定义的局部变量与成员变量同名，这种 情况是允许的，此时方法中通过变量名访问到的是局部变量，而并非成员变 量。

 public class Person {  
	 int age;     
 	void speak(){         
	 int age = 20;        
	 System.out.println("我今年"+age+"岁！");         
 	//System.out.println("我今年"+this.age+"岁！");     
 	}          
	 void say() {      
		 System.out.println("age="+age);     
	 } 
 }

对象的创建与使用

类名 对象名 = new 类名(); 
//如
Person p = new Person(); 

在创建对象后，可以通过对象的引用来访问对象所有的成员

public class ClassObjectMain {  
	public static void main(String[] args) {      
		Person p1 = new Person(); //创建第一个 Person对象      
		Person p2 = new Person(); //创建第二个 Person对象      
		p1.age = 12;              //age属性赋值      
		p1.speak();               //调用对象的方法      
		p2.speak();   
} } 
		//age=12 
		//age=0 

Java 支持 4 种不同的访问权限

类的封装

将属性私有化，提供公有的方法访问私有属性（隐藏对象的属性和 实现细节
就是属性的访问修饰符改成private，变成私有的，提供公有的setter()赋值 方法和getter()取值方法对属性进行访问，在赋值和取值方法中，加入对属 性的限制

public class Person {          
	private String name;          
	private int age;  
	//将 name 和 age 属性设置为私有的，只能本类才能访问，其 他类都访问不了，如此就对信息进行了隐藏
} 

getter和setter方 法。

//getter（用于获取）： 
[非私有修饰符] 字段类型 get字段名称（首字母大写）() {    
 return 字段名； 
 } 
 //setter（用于设置）： 
 [非私有修饰符] void set字段名称（首字母大写）(字段类型 变量) {     
 字段=变量； }

构造方法

①方法名必须与类名相同；
②不声明返回类型；
③在方法中不能使用return语句返回一个值。

public class Boy {     
	private String name;     
	private int age;  
	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){             
			this.age = age;         
		} else {             
			this.age = 0;         
		}  
	}  
	public Boy() {   
		System.out.println("无参构造方法调用....");  
	} 
}

定义有参的构造方法

通过有参的构造方法就可以实现对属性的赋值。

public Boy(int age) {   
	System.out.println("调用一个参数的构造方法...");   
	this.age = age;  
} 

构造方法的重载

在一个类中可以定义多个构造方 法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可 以通过调用不同的构造方法为不同的属性赋值。