黑马程序员--java基础学习笔记6

package com.date6;
/**
 *理解这种二维数组的模式 
 */
public class Test1 {
	public static void main(String[] args) {
		int[][] arr = new int[][]{{1,2,3},{4,5,6}};
		for(int i=0;i<2;i++){
			for(int j=0;j<3;j++){
				System.out.print(arr[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

package com.date6;

public class Test2 {
	public static void main(String[] args) {
		int[][] arr = new int[3][];
		System.out.println(arr);
		System.out.println(arr[0]);	//输出null,因为没有对它进行初始化
		System.out.println(arr[0][0]);
		//由于arr[0]数组为空,如果再查一位数组的元素，
		//肯定会报空指针NullPointerException异常
	}
}

package com.date6;
/**
 *封装:是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
 *
 *好处:
 *将变化隔离，便于使用，提高重用性，提高安全性。
 *
 *封装原则:
 *1.将不需要对外提供的内容都隐藏起来。
 *2.把属性都隐藏，提供公共方法对其访问。如,getXXX,setXXX。
 *
 *1.私有仅仅是封装的一种体现而已。
 *2.private关键字:是一个权限修饰符，用于修饰成员(成员变量和成员函数),被私有化的成员只在本类中有效。
 *3.常用场景之一:将成员变量私有化，对外提供对应的set、get方法对其进行访问，提高对数据的安全性
 *  java中最小的封装体就是函数,类、框架也是封装体。
 */
class Person{
	//private:私有，是一个权限修饰符，用于修饰
	//不希望别人直接访问赋值，需要通过私有化把属性进行隐藏
	private int age;
	
	//提供set、get公共方法对其访问
	public void setAge(int a){
		//在set方法内可以对属性的赋值进行限制
		if(a>0 && a<130){
			age = a;
		}else{
			System.out.println("错误的数据");
		}
	}
	public int getAge(){
		return age;
	}
	void speak(){
		System.out.println("age="+age);
	}
}
public class Test8 {
	public static void main(String[] args) {
		Person p = new Person();
		//通过其他方式访问
		p.setAge(20);
		p.speak();
		//赋值不合法,set方法就不允许成功赋值
		p.setAge(-20);
	}
}

package com.date6;
/**
 * 匿名对象两种使用情况:
 * 1.当对对象方法仅进行一次调用时。
 * 2.匿名对象可以作为实际参数进行传递。
 */
class Car{
	static String color = "red";
	static int num = 4;
	public static void run(){
		System.out.println("function run is running");
	}
	public static void show(){
		System.out.println(num+"..."+color);
	}
}
public class Test5 {
	public static void main(String[] args) {
		//对对象方法仅进行一次调用时，就可以使用匿名对象
		new Car().show();
		//匿名对象可以作为实际参数进行传递
		show(new Car());
	}
	public static void show(Car car) {
		car.color = "black";
		car.num = 3;
		System.out.println("function show is running!");
		System.out.println(car.num+"..."+car.color);
	}
}

package com.date6;
/**
 *基本数据类型参数传递 
 *1.jvm调用main方法,main方法入栈。
 *2.将x变量值设置为3。
 *3.main方法调用show方法，3作为基本数据类型参数赋值给show方法参数x,
 *也就是说，此时show方法的参数x值为3。
 *4.show方法执行x = 4后,show方法的参数x值变成4。
 *5.show方法执行结束，show方法出栈。show方法参数x也随之出栈。
 *6.main方法打印x的值。此时x指的是main方法中的x变量的值(show方法
 *中的参数x已经随show方法一块出栈了)。所以，打印出来的x值为3而不是4。
 *7.main方法执行结束，出栈。
 */
public class Test6 {
	public static void main(String[] args) {
		int x = 3;
		show(x);
		System.out.println("x="+x);
	}
	///下面两种方式打印的x值都是3
	//方式一
	public static int show(int x){
		x = 4;
		return x;
	}
	//方式二
	public static void show1(int x){
		x = 4;
	}
}

package com.date6;
//引用数据类型参数传递
/**
 *执行过程说明:
 * 1.jvm调用main方法,main方法入栈。
 * 2.创建一个Test7对象d(在堆内存中创建，d作为引用变量，指向堆内存中创建的实体对象)，并
 * 将d指向的实体对象中的属性x的值设置为9.
 * 3.main方法调用show方法，d作为引用数据类型参数赋值给show方法参数t,也就是说，此时
 * show方法的参数t和main方法中的变量d同时指向了堆内存中的同一个实体对象。
 * 4.通过t.x调用堆内存当中的属性，并修改其值为4。
 * 5.show方法结束，t的生命周期结束，show方法出栈,但是实际上它已经将堆内存当中的属性值改变了,
 * 同时由于main方法的变量d依然引用着堆内存中的实体对象，因此堆内存中的实体对象不会被垃圾回收器清除。
 * 6.main方法打印d.x的值，此时d指向堆内存当中的那个被修改的对象的引用变量x，明显输出结果为4,而不是9。
 * 7.main方法结束，出栈，同时如果堆内存中的那个对象没有被调用，将会被jvm的垃圾回收器
 * 回收。
 * 
 * 总结：
 * 在java中，方法参数的传递永远都是传值，而这个值，对于基本数据类型，值就是你赋给变量的那个值。
 * 而对于引用数据类型，这个值是对象的引用，而不是这个对象本身。
 */
public class Test7 {
	int x = 3;
	public static void main(String[] args){
		Test7 d = new Test7();
		d.x = 9;
		show(d);
		System.out.println(d.x);
	}
	//下面两种方式打印x的结果都是4
	//方式一
	public static void show(Test7 t){
		t.x = 4;
	}
	//方式二
	public static int show1(Test7 t){
		t.x = 4;
		return t.x;
	}
}

版权声明：本文为博主原创文章，未经博主允许不得转载。