第二周学习总结（深入编程之路）

第二周学习总结

方法

方法：就是使用{}包起来的内容,给{}独立的代码块起一个名字,以便于复用。

	定义方法的格式
	
		1:有具体返回值类型的方法定义
		2:没有具体返回值类型的方法定义

	有具体返回值类型的方法定义
	
	权限修饰符 静态修饰符  返回值类型  方法名(数据类型1 变量名1,数据类型2 变量名2,......){
			业务内容;
			
			return 结果;
	}

方法的调用

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

方法的重载

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

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

数组

一维数组
动态初始化：

标准格式：
数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;

int[] arr = new int[3] ;

静态初始化：

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

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

int[] arr = new int[]{1,2,3} ;
int[] arr = {1,2,3} ;

二维数组

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

二维数组遍历

数组名.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();
	}
}

冒泡排序的思想:

	两两比较,将较大的值往后放,第一次比较完毕,最大值出现在
最大索引处,依次这样比较...
	规律:
			两两比较,将较大的值往后放
			总共比较的次数:数组长度-1次

class ArrayDemo{
	public static void main(String[] args){
		int[] arr = {24,60,87,57,13} ;
		//调用数组遍历的功能
		System.out.println("排序之前:") ;
		printArray(arr) ;
		bubbleSort(arr) ;
		System.out.println("排序之后:") ;
		printArray(arr) ;
	}

	//排序的功能	
	public static void bubbleSort(int[] arr){
		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 ;
				}
			}
		}
	}
	
	//遍历的功能
	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]+", ") ;
			}
		}
	}
}

面向对象

面向对象的概念

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

对象的创建

	对象是对抽象的类的一个实例化,对象的创建需要先创建一个类:
	class  类名{
		数据类型 成员变量1;
		数据类型 成员变量2;
		修饰符 返回值类型 成员方法(参数){
		}
	}

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

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

对象的使用

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

匿名对象

匿名对象是没有名字的对象,一般只使用一次.
定义匿名对象: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;
	}
}

成员变量、局部变量区别

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

什么时候将变量定义为成员变量? 
答：如果变量能够描述生活中事物的属性的话,这个时候将变量定义为成员变量;否则,就局部变量

三大特征之（封装）

private关键字的特点:
1)private可以修饰一个类中的成员变量,也可以成员方法
2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的!(保证数据的安全性)

什么时候将变量定义为成员变量？
答：如果该变量能够描述某个事物属性的话,----变量就要定义成员变量!

封装示例：

class Demo{

	//定义一个成员变量
	int num = 10;
	private int num2 = 30 ; //私有修饰,只能在Demo类中访问,外界要访问需要通过公共的方法来访问!
	
	//成员方法
	public void method(){
		System.out.println(num) ;
		System.out.println(num2) ;
		System.out.println("method demo...") ;
	}
	
	//私有的成员方法
	private void function(){ //私有的方法,只能在本类中访问
		System.out.println("function demo...") ;
	}
	//公共方法
	public void show(){
		function() ;
	}
}
//测试类
class PrivateDemo{
	public static void main(String[] args){
		//创建Demo类的对象
		Demo d = new Demo() ;
		d.num = 50 ; //num成员变量在Demo类中没有被private修饰
		System.out.println(d.num) ;
		//d.num2 = 100 ; //System.out.println(d.num) ;
		//System.out.println(d.num2) ;
		System.out.println("-------------------------") ;
		
		d.method() ;
		//d.function() ;// function() 在 Demo 中是 private 访问控制
		d.show() ;
	}
}

标准类

java标准类也就javaBean,使用javaBean可以封装对象的属性,使得程序安全性提高.

标准类需要满足4个条件:

1.成员变量采用private修饰.
2.为每个成员变量写一对get/set方法
3.有一个无参的构造方法.
4.有一个全参的构造方法.

标准类示例：

class Student {
	 
	private int id; //学号
	private String name;//姓名
	private int age ;  //年龄
	private String sex;//性别
	
	
	public Student(){}//无参构造方法
	public Student(int id,String name){//有参构造方法
		System.out.println("Student有参构造");
		this.id=id;
		this.name=name;	
	}
	public Student(int id,String name,int age ,String sex){
		System.out.println("Student有4个参构造");
		this.id=id;
		this.name=name;	
		this.age=age;
		this.sex=sex;
	}
	
	public void show(){
		System.out.println("id:"+id+"---"+name+"---"+age+"---"+sex);}
	public void setId(int id1){//15
		id = id1 ;
	}
	public int getId(){
		return id;}
	public void setName(String name){
		this.name = name ;
	}

	public String getName(){
		return name;}
	public void setAge(int age){//15
		this.age = age ;}
	public int getAge(){
		return age;}
	public void setSex(String sex){
		this.sex = sex ;}
	
	public String getSex(){
		return sex;
	}
}

构造方法

什么是构造方法:
	1)方法名和类名相同
	2)没有具体的返回值类型
	3)并且连void都没有
	
	权限修饰符 + 方法名就是类名() {
	}
	
	构造方法主要作用:就是给该对象中的数据进行初始化!

构造方法中的注意事项:

	1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,
		
	2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!

示例：

	//使用有参构造方法时，必须先给出无参构造方法
	public Teacher()；

	//提供一个有参构造方法,带一个参数的字符串类型的
	public Teacher(String name){
		this.name = name ;

构造方法的重载

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;
	}
}

成员方法

成员方法的分类:(非静态的成员方法)
	两种情况:
		有返回值类型:
			1)有返回值类型,并且有参数
			2)有返回值类型,没有参数
		没有具体返回值:void代替
			1)没有返回值类型,带参
			2)没有返回值类,不带参