Java学习路程之多维数组、类和对象

一.多维数组
1.二维数组:
定义:保存多个相同类型的一维数组
结构:数据类型[][] 数组名 = 初值
声明方式:声明方式与一维数组的声明方式类似
方法1:int[][] array = new int[数组长度][一维数组长度];
方法2:int[][] array = new int{{1, 2, 3},{4, 5, 6}};
方法3:int[][] array = {{1, 2, 3},{4, 5, 6}};

public class Day05 {
	public static void main(String[] args) {
		//1.声明一个有两个一位数组,并且每个一位数组有三个元素的二维数组
		int[][] array1 = new int[][] {
			{1, 2, 3},{4, 5, 6}
		};
		//遍历二维数组(一维数组遍历使用for循环,二维数组遍历使用双重循环以此类推)
		for(int i = 0; i< array1.length; i++){
			for(int j = 0; j < array1[i].length; j++){
			System.out.print(array1[i][j]);
			}
			System.out.println();
		}
	}
}

2.三维数组
定义:保存相同类型的二维数组
结构:
数据类型 [][][] 数组名 = 初值;
三维数组的声明方式与二维数组的声明方式类似只是多了一个[].

public class Day05 {
	public static void main(String[] args) {
		//声明一个有两个二维数组,每个二维数组中有三个一维数组,每个一位数组中有三个元素的三维数组
		int[][][] array2= {
				{
					{1, 2, 3},
					{4, 5, 6}
				},
				{
					{7, 8, 9},
					{10, 11, 12}
				}	
		};
		//遍历三维数组并求这个三维数组所有元素的和
		int sum = 0;
		for (int i = 0; i < array3.length; i++) {
			for (int j = 0; j < array3[i].length; j++) {
				for (int k = 0; k < array3[i][j].length; k++) {
					System.out.print(array3[i][j][k] + " ");
					sum = sum + array3[i][j][k];
				}
				System.out.println();
			}
			System.out.println();
		}
		System.out.println("总和:" + sum);
	}
}

二.类和对象
1.面向过程和面向对象
面向过程:
强调过程,每一个步骤,过程的执行者
面向对象:
强调的是对象,有执行者变成了指挥者
面向对象的好处:
1.1懒人思维
1.2将复杂的问题简单化
1.3从事物的执行者转变成事物的指挥者
2.类和对象
类:对抽象事物的描述(模板)
类中包含属性(成员变量)和行为(方法)
对象:对抽象事物的具体描述(利用类创造出来的事物,所以Java中先有类后有对象)
创建对象:类名 对象名 = 初值

public class Day05 {
	public static void main(String[] args) {
		//创建一个学生对象
		//new会在堆内存中开辟一块空间,保存成员变量
		//等号前是对象的引用(保存对象地址)
		Student student1 = new Student();
		//为对象的成员变量赋值
		student1.name = "李四";
		student1.age = 20;
		student1.gender = "男";
		//取值
		System.out.println(student1.name);
		System.out.println(student1.age);
		System.out.println(student1.gender);
		//调用成员方法
		//对象名.方法名(参数)
		//成员方法跟函数一样会进栈执行
		student1.eat();
		student1.sleep();
		student1.playGame("王者荣耀");
		{
			输出结果:
			李四
			25
			男
			吃饭
			睡觉
			玩王者荣耀
		}
		//两个引用指向了同一个内存空间
		Student student2 = student1;
		student2.name = "王龙";
		System.out.println(student1.name);
		{
			输出结果为:王龙
		}
	}
	上面代码在内存中的表现如图:(https://img-blog.csdn.net/20180824204645691?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2w3MTA4MjA3NDI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
	/*
 * 使用关键词class创建一类
 * 注意:一个.Java文件中可以创建多个不同的类,但是使用public修饰的类,一个文件只能有一个,并且这个用public修饰的类必须与文件名保持一致
 * 学生类
 * 属性:姓名 年龄 性别
 * 行为:
 * 吃饭
 * 睡觉
 * 打游戏
 */
 class Student {
     //属性(位置在类中方法外)
	 String name;
	 int age;
	 String gender;
	 //方法
	 public void eat(){
		 System.out.println("吃饭");
	 }
	 public void sleep(){
		  System.out.println("睡觉");
	 }
	 public void playGame(String gameName) {
		System.out.println("玩" + gameName);
	}
 }
}

3.成员变量和局部变量的区别
1)生命周期
成员变量:随着对象的创建而创建,对象的销毁而销毁
局部变量随着方法的执行而创建,方法的结束而销毁
2)书写位置
成员变量:类中方法外
局部变量:方法上或方法中
3)作用域
成员变量:在整个类中都可使用
局部变量:在方法的作用域内有效
4)初值
成员变量:如果没有初值系统会自动分配初值(基本数据类型初值为0,引用数据类型为null)
局部变量:没有初值会报错,不能使用
5)在内存中表现
成员变量:保存在堆区
局部变量:运行在栈区

public class Day05 {
	public static void main(String[] args) {
		Car car1 = new Car();
		car1.sayHi();
		car1.run();
	}
	/*
 * 车类Car
 * 车名 排气量 颜色
 * 开车
 * 停车
 * 介绍自己的方法(输出自己所有的成员变量的方法)
 */
class Car{
	//车名
	String name = "红旗尊享版";
	//排量
	String displacement = "涡轮增压4.0";
	//颜色
	String color = "白色";
	//局部变量的书写位置:声明在方法上或者方法中
	//局部变量的作用域:在方法的作用域内
	//开车
	public void run(){
		//就近原则
		String name = "李四";
		System.out.println(name);
		System.out.println("开车");
		/*
		 * 局部变量不给初值不能直接使用
		 * int num;
		System.out.println(num);*/
	}
	//介绍自己的方法
	public void sayHi() {
		//成员变量的作用域,在整个类里都可访问到
		System.out.println("车名:" + name);
		System.out.println("排量:" + displacement);
		System.out.println("颜色:" + color);
	}
} 
//输出:
{
	车名:红旗尊享版
	排量:涡轮增压4.0
	颜色:白色
	李四
	开车
}

4.匿名对象

作用:
1.省略代码
2.一般可以当做参数来使用
public class Day05 {
	//修改对象的name
	//Person p = p1;
	//引用数据类型,参数传递的是地址
	public static void fn(Person p) {
		p.name = "张三";
		p.sayHi();
	}
	
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "李四";
		p1.age = 16;
		p1.sayHi();
		//调用方法
		fn(p1);//输出:张三
		p1.sayHi();
		
		//创建匿名对象
		//new 开辟了三个内存空间之间没有联系
		new Person().name = "网红";
		new Person().age = 14;
		new Person().sayHi();
		//可以当做参数来用,减少代码
		fn(new Person());
		//测试方法时使用
	}
}

5.成员变量私有化(get和set方法)
1.面向对象的特征:封装,继承,多态
2.将代码的实现或者属性隐藏起来,不让外界直接访问
3.被private修饰的成员变量,只能被本类进行访问
javaBean(实体类)规范:
1.成员变量私有化
2.提供get/set方法

public class Demo06 {
	public static void main(String[] args) {
		Phone p1 = new Phone();
		p1.setName("诺基亚");
		System.out.println(p1.getName());
	}
}

class Phone{
	//成员变量私有化
	private String name;
	private String color;
	//私有化之后需要提供对外的访问方法
	//每个成员变量需要提供一对方法 赋值(set方法)和取值(get方法)
	//方法命名规范set+成员变量名(使用的是小驼峰)
	//set方法
	public void setName(String name) {
		//就近原则
		//使用关键字this
		//this表示本类的对象
		//this.name表示本类的name属性
		//this 谁调用了这个方法 这个对象就是this
		this.name = name;
	}
	//get方法
	public String getName() {
		return name;
	}
	//color
	public void setColor(String color) {
		this.color = color;
	}
	public String getColor() {
		return color;
	}
	public void sayHi() {
		System.out.println(name +" "+ color);
	}
}