Java学习笔记（二维数组\面向对象\类、方法、构造器）--day_5

【1】没有多维数组
Java语言提供了多维数组的语法，但多维数组实质上还是一维数组。Java语言里的数组类型是引用类型，因此，数组变量其实是一个引用，这个引用指向真实的数组内存。数组元素的类型也可以是引用，如果数组元素的引用再次指向真实的数组内存，这种情形看上去很像多维数组。
定义二维数组的语法：
type[ ] [ ] arrName;

public static void main(String[] args)
    {
	//定义一个二维数组
	int[ ] [ ] a; 
//把a当成一维数组进行初始化，初始化a是一个长度为3的整数
	//a数组的数组元素又是引用类型
	a = new int[3][ ]; 
	//把a数组当成一维数组，遍历a数组的每个元素
	for (int i = 0; i < a.length; i++)
	{
		System.out.println(a[i]);
	}
	//初始化a数组的第一个元素
	a[0] = new int[2]; 
	//访问a数组的第一个元素所指数组的第二个元素
	a[0][1] = 6; 
//a数组的第一个元素是一个一维数组，遍历这个一维数组
	for (int i = 0; i < a[0].length; i++)
	{
		System.out.println(a[0][i]);
	}
	}
}

我们可以得到一个结论：二维数组是一维数组，其数组元素是一维数组；三维数组也是一维数组，其数组元素是二维数组；四维数组还是一维数组，其数组元素是三维数组……从这个角度来看，Java语言里没有多维数组。

【2】二维数组初始化

public class A2 
{
	public static void main(String[] args) 
	{
		int[][] a=new int[][]{
			new int[2],//二维数组动态初始化
			new int[3],
			new int[5]
	};
	for(int i=0;i<a.length;i++)
		{
			int[]y=a[i];
			for(int j=0;j<y.length;j++)
			{
			System.out.print(y[j] + "\t");
			}
			System.out.println();
		}
		System.out.println(a.length);

		int [][] b=new int [][]{
			new int[]{22,23,25},//二维数组静态初始化
			new int[]{5,20,53},
			new int[]{256,908,897,776}
		};
		System.out.println(b.length);
		
		/*二维数组的遍历*/
		for(int i=0;i<b.length;i++)
		{
			for(int j=0;j<b[i].length;j++)
			{
			System.out.println(b[i][j]);
			}
		}
		int [][]c=new int[][]{
		new int[4],
		new int[]{4,5,8},
		new int[3]
		};
		System.out.println(c.length);
	}
	for(int[] it:c)//for(变量：数组名)
		{
			for(int ix:it)//(变量：数组名)
			{
			System.out.print(ix + "\t");
			}
			System.out.println();
		}
		System.out.println(c.length);
	}
}

public class Aa
{
	public static void main(String[] args) 
	{
		int[][] arr=new int[4][5];//二维数组初始化
		int[][] b=new int[][]{
		new int [5],
		new int [5],					
		new int [5],
		new int [5]
		};
		
		System.out.println(arr.length);
	}
}
 

【3】面向对象
面向对象是一种更优秀的的程序设计方法，它的基本思想是使用类、对象、继承、封装，消息等基本概念来进行程序设计。它是从现实世界中客观存在的事物（即对象）出发来构造软件系统，并在系统构造中尽可能运用人类的自然思维方式，强调直接以现实世界中的事物（即对象）为中心来思考问题，认识问题，并根据这些事物的本质特点，把它们抽象地表示为系统中的类，作为系统的基本构成单元（而不是用一些与现实世界中的事物相关比较远，并且没有对应关系的其它过程来构造系统），这使得系统可以直接映射客观世界，并保持客观世界中事物及其相互关系的本来面貌。
如果采用面向对象方式开发的软件系统，其最小的程序单元是类，这些类可以生成系统中的多个对象，而这些对象则直接映射成客观世界的各种事物。

【4】面向对象的特征
面向对象方法具有三个基本特征：继承（Inheritance）、封装（Encapsulation）和多态（Polymorphism）。
面向对象还支持如下几个功能：
对象是面向对象方法中最基本的概念，它的基本特点有：标识惟一性、分类性、多态性、封装性、模块独立性好。
类是具有共同属性、共同方法的对象的集合。类是对象的抽象；对象则是类的实例。而类是整个软件系统最小的程序单元，类的封装性将各种信息细节隐藏起来，并通过公用方法来暴露该类对外所提供的功能，从而提高了类的内聚性，降低了对象之间的耦合性。
对象间的这种相互合作需要一个机制协助进行，这样的机制称为“消息”。消息是一个实例与另一个实例之间传递的信息。
在面向对象方法中，类之间共享属性和操作的机制称为继承。已有的类可当作基类来引用，则新类相应地可当作派生类来引用。继承具有传递性。可分为单继承（一个继承只允许有一个直接父类，即类等级为树形结构）与多继承（一个类允许有多个直接父类）。

【5】定义类
定义类的语法格式:
[修饰符] class 类名 {….类体……}
类体可以由多个属性、方法、构造器组成。
注意:类的修饰符可以是public、final|abstract 或省略这两个。
类名只要是合法的标识符.
一个类里可以包含三种最常见的成员：构造器、属性、方法。

【6】方法
[修饰符] 方法返回值类型 方法名(形参列表) {….方法体….}
方法中的修饰符可以是public ,protected,private,static,final,abstract,其中访问控制符只能出现一个,abstract ,final 只能出现其一.
返回值类型可以是基本类型和引用类型,如果无返回值,要用void 来声明
形参列表,可以由零到多组组成,参数之间用逗号(“,”)隔开.
static 是一个特殊的关键字,译为”静态”,所有有static 修饰的叫类属性,类方法,类成员.

public class Person
{
	// 下面定义了两个成员变量
	public String name;
	public int age;
	// 下面定义了一个say方法
	public void say(String content)
	{
		System.out.println(content);
	}
}

【7】构造器
[修饰符] 构造器名(形参列表) {……}
修饰符可以是public protected private 构造器必须和类名相同,形参和方法的形参一样.

构造器最大的用处就是在创建对象时执行初始化，系统会默认的进行初始化。如果程序员没有Java 类提供任何构造器，则系统会为这个类提供一个无参的构造器。一旦程序员提供了自定义的构造器，遇系统不再提供默认的构造器。

创建对象的根本途径就是构造器,所以创建对象通过关键字new 加上对应的构造器即可.
如果访问权限允许,类里定义的属性和方法可以通过类或实例来调用,
有static 修饰的访求和属性,既可通过类来调用,也可以通过实例来调用.

public class ConstructorTest
{
	public String name;
	public int count;
	// 提供自定义的构造器，该构造器包含两个参数
	public ConstructorTest(String name , int count)
	{
		// 构造器里的this代表它进行初始化的对象
		// 下面两行代码将传入的2个参数赋给this代表对象的name和count实例变量
		this.name = name;
		this.count = count;
	}
	public static void main(String[] args)
	{
		// 使用自定义的构造器来创建对象
		// 系统将会对该对象执行自定义的初始化
		ConstructorTest tc = new ConstructorTest("张三" , 90000);
		// 输出ConstructorTest对象的name和count两个实例变量
		System.out.println(tc.name);
		System.out.println(tc.count);
	}
}