学习JAVA的第二周

一、JAVA中的方法

1、方法的定义

权限修饰符 静态修饰符 返回值类型 方法名(数据类型1 变量名1,数据类型2 变量名2,…){
语句块
return 结果;
}
修饰符用来修饰方法的访问权限。
返回值得类型是方法返回的值得类型，如果无返回值则写void。
方法名是方法的标识符。
括号里的参数是形式参数，需要带数据类型。

2、方法的调用

	同类中的方法调用：
		有返回值的方法调用：方法返回值的数据类型 变量名 = 方法名（参数）；
		无返回值的方法调用：方法名（参数）；

3、方法重载

为了将功能相似的方法定义同一个方法名，JAVA提供了方法重载技术，即overload。
方法重载是方法名相同，但是参数列表不同。
参数列表不同包括：参数的数据类型不同，参数的数量不同，参数的数据类型的顺序不同。
与返回类型无关，与变量名无关
如以下几个重载关系的方法:

	public  void oppo(){}
	public  int oppo( int a){}
	public  void oppo(double d,int a){}
	public  double oppo(int a,double d){}

二、数组

1.一维数组

1.1数组的概念

数组是用来存放同一种数据类型的容器.

1.2数组的创建

1.21动态初始化:

		数据类型[] 数组名=new 数据类型[数组长度];
		数据类型 数组名[]=new 数据类型[数组长度];
	初始化的数组元素默认值为0.

1.22静态初始化:

	标准格式:
		数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,,,,} ;
		数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3,,,,} ;

	简写方式:(推荐)
		数据类型[] 数组名称 = {元素1,元素2,元素3,,,,}  ;
		数据类型 数组名称[] = {元素1,元素2,元素3,,,,}  ;

1.3数组的应用

	数组的长度:数组名.length;
	数组的下标最大值为:数组名.length-1;
	数组的遍历:采用for循环遍历.

public static void printarr(int [] arr){
		System.out.print("[");
		for(int i=0;i<arr.length;i++){
			if(i==(arr.length-1)){
				System.out.println(arr[i]+"]");
			}else {
				System.out.print(arr[i]+", ");
			}
		}
	}

2.二维数组

2.1数组的创建

格式1:

指定了一维数组的个数,一维数组的长度需要动态给定
数据类型[][] 数组名称 = new 数据类型[m][] ;
举例:
	int[][] arr = new int[3][] ;

格式2:

数据类型[][] 数组名称 =
new 数据类型[][]{{元素1,元素2,元素3…},{元素1,元素2,元素3,…},{,}};
举例
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;

格式3:

数据类型 [][] 数组名称 = {{元素1,元素2,元素3…},{元素1,元素2,元素3,…},{,}};
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;

2.2数组的使用

数组名.length;//数组的行数
数组名[i].length//数组的列数

	二维数组的遍历:
			public static void print2Arr(int [][] arr){
		for(int i=0;i<arr.length;i++){
		System.out.print("{");
			for(int j=0;j<arr[i].length;j++){
				if(j==(arr[i].length-1)){
					System.out.println(arr[i][j]+"}");
				}else {
					System.out.print(arr[i][j]+", ");
			}
			}
		System.out.println();
		}
	}

3.数组的排序算法

3.1冒泡排序法

冒泡排序的思想:
两两比较,第一次比较完毕之后,最大出现在最大索引处,依次这样,可以得到一个排序的数组
规律:
两两比较,大的往后方法
比较的次数:数组长度-1次

//冒泡排序代码:
for(int x = 0 ; x < arr.length-1 ; x ++){
	for(int y = 0 ; y < arr.length-1-x ; y++){
		if(arr[y] > arr[y+1]){
			int temp = arr[y] ;
			arr[y] = arr[y+1] ;
			arr[y+1] = temp ;
		}
	}
}		

3.2选择排序法

三、面向对象

1.面向对象的概念

万物皆对象,每个对象具有自己的属性和行为.
面向对象就是一对象为核心,通过对象来访问对象的属性和方法来完成一系列功能.
类是对象的模板,是JAVA语言用来描述现实事物的最小单位,而对象就是对类的实例化.

2.对象的创建

1.对象是对抽象的类的一个实例化,对象的创建需要先创建一个类:

		class  类名{
			数据类型 成员变量1;
			数据类型 成员变量2;
			修饰符 返回值类型 成员方法(参数){
			}
		}

2.通过new关键字,创建一个对象;

		类名 对象名=new 类名();

3.对象的使用

		java中通过对象来访问其属性和方法:
		对象名.成员变量;
		对象名.成员方法();

4.匿名对象

		匿名对象是没有名字的对象,一般只使用一次.
		定义匿名对象:new Student()

	//匿名对象作为参数使用:
	class Student{
		public void demo(Student stu){
		}
	}
	class Demo {
		public static void main(String[] args){
			Student stu=new Student();
			stu.demo(new Student());//使用方法Demo;
		}
	}

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

1.内存空间不同:
局部变量是在栈中开辟空间;成员变量是在堆中开辟空间.
2.定义位置不同:
局部变量是定义在方法中,随着方法的结束而释放.成员变量是定义在类中,与方法平级.
3.初始化不同:
局部变量必须手动初始化后才可以使用,而成员变量系统会默认初始化.
4.生命周期不同
局部变量在使用完毕后就会释放,成员变量再使用方笔后需要等到垃圾回收器空闲时释放.

4.形参是基本类型与引用类型的区别

5.标准类(javaBean)

6.面向对象的三大特征

6.1封装

JAVA语言的封装是将对象的属性封装到类中,使得外部不能直接访问,并提供相应的方法供对象来使用.大大提高了数据的安全性,扩展性.
封装的应用有javaBean,接口等.一个标准类也就是JavaBean实现的就是封装技术.一个标准类(javaBean)

6.2继承

6.3多态

7.构造方法

构造方法满足2个条件:
1.没有返回类型,甚至没有void.
2.方法名与类名相同.
构造方法重载与普通方法重载是一样的.

	class Photo{
		private String brand ; //品牌
		private String color;//颜色
		private double price;//价格
		
		public Photo(){}
		public Photo(String brand,double price){
			System.out.println("Photo二个参数有参构造");
			this.brand=brand;
			this.price=price;
		}
		public Photo(String brand,double price,String color){
			System.out.println("Photo三个参数有参构造");
			this.brand=brand;
			this.color=color;
			this.price=price;
		}
	}

	注意:如果不定义构造方法(包括有参和无参),编译器会提供一个无参的构造方法.