java变量和面向对象

数组

数组的静态初始化

指定数组的具体元素值,由系统默认分配它的长度!

如何静态初始化数组

数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....}    
          int[] arr = new int[] {1,2,3} ;

简化版本

int[] arr = {};

注意定义一个数组不能动态静态初始化一起使用

数组的应用

数组的遍历:

需要将数组中的元素一一获取出来

public class ArrayTest2 {

	public static void main(String[] args) {
		//定一个数组,静态初始化
		int[] arr = {11,22,33,44,55} ;
        printArray(arr);
     /**
	 * 定义一个遍历数组的方法
	 * 两个明确
	 * 		1)明确返回值类型:void
	 * 		2)明确参数类型 int[]
	 */
    public static void printArray(int[] arr) {
		//遍历arr数组
		for(int x = 0  ; x <arr.length ; x ++) {
			System.out.print(arr[x] +" ");
		}
	}

最值

public class ArrayTest3 {
	
	public static void main(String[] args) {
		//自定一个数组,静态初始化
		int[] arr = {24,64,50,55,10} ;
        int max = getMax(arr) ;
		System.out.println("最大值是:"+max);    
}
        /**
	     * 两个明确
	     * 	1)明确返回值类型:int
	     * 	2)明确参数类型:int[] 数组
	     */
         public static int getMax(int[] arr) {
		//定义参照物,假设为最大值
		int max = arr[0] ;
		
		//遍历其他元素
		for(int x = 1 ; x < arr.length ; x ++) {
			//后面的元素依次和参照物进行比较,确定最大值
			if(arr[x] > max) {
				max = arr[x] ;
			}
		}
		
		
		return max ;
	}
}

一个数组的最大值

元素逆序

public class ArrayTest4 {
	
	public static void main(String[] args) {
		//定义一个数组,静态初始化
		int[] arr = {24,64,50,55,10} ;
		
		//逆序前
		System.out.println("逆序前:");
		printArray(arr);
		
		System.out.println("逆序后:");
//		reverse(arr);
		reverse2(arr);
		printArray(arr);
	}
	
	/**
	 * 定义一个元素逆序的方法
	 * 		1)确定返回值类型:void   
	 * 		2)明确参数类型:int[]
	 */
    public static void reverse(int[] arr) {
    for(int x = 0 ; x < arr.length/2 ; x ++) {
			int temp = arr[x] ;
			arr[x] = arr[arr.length-1-x] ;
			arr[arr.length-1-x] = temp ;
		}
	}
    /**
	 * 遍历数组
	 */
	public static void printArray(int[] arr) {
		System.out.print("[");
		//遍历元素
		for(int x = 0 ; x < arr.length ; x ++) {
			//判断是否是最后一个元素
			if(x==arr.length -1) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
}

 

基本元素的查找

基本查找法:从头查到尾...                                
     数组高级部分:二分查找/折半查找

public class ArrayTest6 {
	
	public static void main(String[] args) {
		//定一个数组
		int[] arr = {10,24,69,80,53,17} ;  
int index = getIndex(arr, 69) ;
		System.out.println("该元素在数组中的索引是:"+index);
public static int getIndex(int[] arr,int value) {
		//遍历数组
		for(int x =0 ; x < arr.length ; x ++) {
			//判断 如果要查找的value元素和arr[x]一致,返回x索引即可
			if(arr[x] == value) {
				return x ;  
			}
		}
return - 1;
	}

面向对象

面向对象的特点：

 面向对象的思想更符合我们生活中的思想行为习惯

让一个复杂的事情简单化

角色发生变化：让我们从执行者变成了指挥者

面向对象的特征：封装、继承、多态

封装

封装:就是将一个类中的成员变量私有化,对该类提供一些公共的访问方法!

关于private关键字:
       private :私有的,不能访问的

被private修饰的成员变量/成员方法,只能在本类中访问,外界不能够直接访问

class Student{
	//提供两个变量
	String name ;
	private int age ;
	
	//提供show(),作用:输出成员变量的
	public void show() {
		System.out.println(name+"---,"+age);
	}
//测试类
public class StudentDemo {

	public static void main(String[] args) {
		
		//创建Student类的对象
		Student s = new Student() ;
		
		//赋值
		s.name = "柔柔" ;
 s.show();

       

局部变量和成员变量的区别

 在类中位置不同

局部变量：在方法定义中或方法声明上

成员变量：在类中，方法外

 在内存中的位置不同

局部变量：在栈内存

成员变量：在堆内存

 生命周期不同

局部变量：随着方法调用而存在，随着方法调用结束而消失

成员变量：随着类的加载而加载，随着类的加载结束而消失(等待GC空闲状态)

 初始化不同

局部变量：必须在使用之前进行初始化

成员变量：可以不用初始化

 形式参数的问题：

 形式参数是基本数据类型：形式参数的改变，对实际参数没有影响

 形式参数是引用数据类型：形式参的改变：会直接影响实际参数

则：如果一个方法的形式参数是一个引用数据类型，就需要创建该引用类型的具体对象

  匿名对象：没有名字对象

 格式：new 类名() ;

 匿名对象的好处:

 调用一次即可，不适合调用多次

 调用完之后，会立即从内存释放掉，及时被GC垃圾回收器回收掉

 可以作为参数进行传递