数组的使用、方法的定义及使用（包括方法的重写与重载、方法的递归调用）、封装性的初步分析

数组的使用

数组的定义

数组类型[] 数组名=new 数组类型[数组长度]//第一种方法
数组类型[] 数组名=new 数组类型[]{数组元素0，数组元素1...}//第二种方法
数组类型[] 数组名=new 数组类型{数组元素0，数组元素1...}//第三种方法

 最大的索引是“数组的长度-1”（数组的角标值从0开始，所以x=0 x<arr.length或x<=lengtn-1）lengtn→元素个数

数组遍历

for(int i = 0;i< arr.length;i++){//进行遍历
    System.out.print(i+"\t");//输出其中的元素
}
System.out.println();//输出换行

 数组最值（最小值的比较不是角标大小而是数组中元素的大小）

 public static int getMax(int[] arr)  
14.	    {  
15.	        //定义变量。初始化为数组中任意一个元素即可。  
16.	        int max = arr[0];  
17.	        //通过循环语句对数组进行遍历。  
18.	        for(int x=1; x<arr.length; x++)  
19.	        {  
20.	            //如果遍历到的元素比变量中的元素大，就赋值给该变量；  
21.	            if(arr[x]>max)  
22.	                max = arr[x];  
23.	        }  
24.	        return max;  
25.	    }   
26.	    

数组排序（插入数序、快速排序、选择排序、冒泡排序） 

		int[] num=new int[5];
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数组：");
		for(int i=0;i<num.length;i++) {
			num[i]=sc.nextInt();
		}
		System.out.println("数组为：");
		for(int n:num) {
			System.out.print(n + " ");
		}
		System.out.println();
		int temp=0;
		for(int i=0;i<num.length-1;i++) {
			for(int j=0;j<num.length-i-1;j++) {
				if(num[j]>num[j+1]) {
					temp=num[j];
					num[j]=num[j+1];
					num[j+1]=temp;
				}
			}
		}
		System.out.println("从小到大排序：");
		for(int n:num) {
			System.out.print(n + " ");
		}

1.  声明一个数组

   String[] aArray = new String[5];  
   String[] bArray = {"a","b","c", "d", "e"};  
   String[] cArray = new String[]{"a","b","c","d","e"};  
   

2. 输出一个数组

   int[] intArray = { 1, 2, 3, 4, 5 };  
   String intArrayString = Arrays.toString(intArray);
   System.out.println(intArray); 
   System.out.println(intArrayString);  

3. 从一个数组创建数组列表

   String[] stringArray = { "a", "b", "c", "d", "e" };  
   ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
   System.out.println(arrayList);  

4.  检查一个数组是否包含某个值

   String[] stringArray = { "a", "b", "c", "d", "e" };  
   boolean b = Arrays.asList(stringArray).contains("a");  
   System.out.println(b);  

5. 连接两个数组

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] intArray2 = { 6, 7, 8, 9, 10 }; 
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);  

方法的定义及使用（包括方法的重写与重载、方法的递归调用）

方法

修饰符 返回类型 方法名(参数列表){
	方法体	
}
//实例
public int add(int firstNum,int secondNum){
	return firstNum + secondNum;
}

return： 是Java关键字有两层含义。

1. 代表方法结束，离开此方法；
2. 后面跟着计算结果，把计算结果返回调用方，return只能返回一个值。

方法的重载

public class Example05{
//两个整数型相加
public static int add01(int x,int y){
return x+y;
}
//两个小数相加
public static double add02(double x,double y){
return x+y
}
public static void main(String[] args){
//针对求和方法的调用
int sum1=add01(1,2);
double sum2=add02(0.2,5.3)
//打印求和结果
System.out.println("sum1="+sum1);
System.out.println("sum2="+sum2);
}
}

 方法的递归(如果递归次数太多就会导致内存溢出)

public static void main(String[] args) {
System.out.println(sum(100));

	}
	public  static int sum(int num) {
		
		return num+sum(num-1);
	}

对象：某一个具体的事物、实体或事例
类：具有相同属性和行为的一些对象的统称或集合（类中只有定义，执行在函数中，成员变量在类中定义，可初始化，若不初始化系统默认初始化，但不能在类中写执行语句）
类由属性和行为标识
eclipse中，一个.java程序只有一个public修饰的类，该类包括main方法，称为主类
实体类：描述事物的类
工具类：Arrays Math System等为工具类
主类：主函数所在类，描述当前程序，主函数就是一个程序的开始

封装性的初步分析

使用者对类内部定义的属性( 对象的成员变量) 的直接操作会导致数据的错误、混乱或安全性问题。

（保护的方式：信息隐藏）

封装方法的实现

 1、在类中使用private私有化成员变量。
2、创建setter方法，使其他类可以通过此方法为变量赋值。
3、setter方法里设置限定条件。
4、给出getter方法，使其他类能够输出合理数据

 构造方法

[修饰符] 方法名 （[参数列表]）{
//方法体
}

1. 方法名和类名相同
2. 方法名的前面没有返回值类型的声明
3. 在方法中不能使用return语句 返回一个值

构造方法的重载

public class Example02{
	private int age;
	private String name;
	public example(int age,String name){
		this.age=age;
		this.name=name;
	}
	public example(int age){
		this(age,"coffee");//调用 example(int age,String name)构造方法
	}
	public example(){
		this(1);//调用 example(int age)构造方法
	}
	public void setName(String name) {this.name=name;}
	public String getName() {return name;}
	public void setAge(int age) {this.age=age;}
	public int getAge() {return age;}

example a=new example(2,"lucky");
example b=new example(2);
example c=new example();
String name = a.getName();
String name1 = b.getName();
int age = c.getAge();
System.out.println(name);
System.out.println(name1);
System.out.println(age);

匿名对象:

创建对象的标准格式
类名称  对象名   = new  类名称();
匿名对象只有右边的对象,没有左边的名字和赋值运算符.
匿名对象只能使用一次. 如果确定只需要使用唯一一次,那么就可以使用匿名对象.
 

public class Example01 {

	public static void main(String[] args) {
		
		Animal dog = new Animal ();
		
		dog.setAge(2);
		dog.setName("lucky");
		System.out.println(dog.getAge());
		System.out.println(dog.getName());
		dog.show();
		
		
		//匿名对象
		//设置不进去,因为匿名对象使用的时候仅仅方法只调用一次,方法调用结束就会消失.
		//这是三个全新的对象,每个地址自都不一样.
		new Animal().setAge(2);
		new Animal().setName("coffee");
		new Animal().show();
		
	}
	
}