Java学习的第二周

Java学习的第二周

1.数组

        //数组的动态初始化
		int[] arr = new int[3] ;  //堆内存空间地址
		int[] arr2 = new int[2] ;//堆内存空间地址

		// 打印数组名，输出的是数组的地址值
		System.out.println(arr) ; //[I@6d06d69c      
		System.out.println(arr2) ;//[I@7852922

		//定义第三个数组对象
		int[] arr3 = arr ; //将一个对象赋值给另一个对象--->将地址值赋值给第三个数组
		arr3[0] = 20 ;     // arr[0]的值发生改变
		arr3[1] = 70 ;	   // arr[1]的值发生改变
		System.out.println(arr[0]) ;  // 20
		System.out.println(arr[1]) ;  // 70

注意：

int[] arr = new int[2]{10,20} ; 错误的,动态初始化和静态初始化不能一起使用

2.数组中常见的异常

	数组中会遇见的一些异常:
	异常:Throwable 类
	异常分为两大类:
			Error:程序出现了严重的问题;
			Exception:
				RuntimeException:运行时期异常 
					java.lang.ArrayIndexOutOfBoundsException属于运行时期异常的一种
					java.lang.NullPointerException属于运行时期异常的一种
						
				编译时期异常(只要不是RuntimeException的异常都属于编译时期)
		
	
		java.lang.ArrayIndexOutOfBoundsException:属于运行时期异常的一种
						数组角标越界异常
								出现的原因:访问了数组中不存在的角标值
								解决方案:更改角标在范围内即可!
								
								
		java.lang.NullPointerException:空指针异常(引用类型中经常会出现的异常!)
		出现的原因:
				代码结构不严谨(某个对象已经为null,还有使用这个对象调用方法或者访问元素...)
		解决方案:
				只要 给对该对象进行非空判断
				如果该对象不为空,才能使用这个对象完成一些操作!

举例：

class ArrayDemo4{
	public static void main(String[] args){
		
		//定义一个数组,静态初始化
		int[] arr = {1,2,3} ; //new int[]{1,2,3} ;
		
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		//该数组最大的角标值是2
		//System.out.println(arr[3]);  //java.lang.ArrayIndexOutOfBoundsException  :数组角标越界
		
		//Javac  ArrayDemo4.java -----> 编译的时候,检查这类中所有的Java语法
		
		
		//引用类型的默认值是null
		//arr = null ;
		//System.out.println(arr[0]) ; //java.lang.NullPointerException:空指针异常
		
		arr = null ;
		//加入一个逻辑判断:非空判断
		if(arr!=null){
			System.out.println(arr[0]) ;
		}else{
			System.out.println("该对象为空了,不能再使用这个对象了") ;
		}
	}
}

数组的遍历：

**数组中:提供了一个属性:length属性:获取数组中的长度
//最大的角标值=数组的长度-1 = 数组名称.length -1 ;

for(int x = 0 ; x < arr.length ; x ++){
	System.out.print(arr[x]+" ") ;
}                                      

重点：

数组中有没有length属性,字符串中有没有length属性,集合中有没有length属性

	数组中:存在length属性
	字符串没有length属性------->String类中:length()
	集合中没有length属性------->集合中:size()

3.冒泡排序

思想：

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

伪代码：

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

4.二维数组

定义：

二维数组:
			其实就是一个元素为一维数组的数组
			
	定义格式:
	数据类型[] 数组名称[] ;
	数据类型[][] 数组名称 ;
	
	动态初始化:
		格式1:
			数据类型[][] 数组名称 = new 数据类型[m][n] ;
		举例:
			 int[][] arr = new int[3][2] ;
		=号左边:
			int:当前数组存储的是int类型的元素
			[][]:定义的是一个二维数组
			arr :数组对象名称
		=号右边:
			new :在堆内存中创建该数组的对象(产生堆内存空间地址)
			int:当前数组存储的是int类型的元素
			[3]:当前定义的这个二维数组中有3个一维数组
			[2]:每一个一维数组中有2个长度

注意事项：

在一些笔试题:定义变量 进行初始化
			int x, y ;  x 和y是两个int类型的变量
			int x [],y[] ;x和y都是int类型的数组
			int x[][],y[] ; x是一个二维数组,y是一个一维数组

举例：

class ArrayDemo{
	public static void main(String[] args){
		//格式1:
		 int[][] arr = new int[3][2] ;
		 System.out.println(arr);//[[I@6d06d69c      //地址值
		 System.out.println(arr[0]) ;//[I@7852e922	//地址值
		 System.out.println(arr[1]) ;//[I@4e25154f	//地址值
		 System.out.println(arr[2]) ;//[I@70dea4e	//地址值
		 
		 System.out.println(arr[0][1]) ;
		 System.out.println(arr[1][1]) ;
		 
		 arr[0][1] = 10;
		 arr[0][0] = 20 ;
		 arr[1][1] = 40 ;
		 System.out.println("-----------------------") ;
		 System.out.println(arr);//[[I@6d06d69c			//地址值
		 System.out.println(arr[0]) ;//[I@7852e922		//地址值
		 System.out.println(arr[1]) ;//[I@4e25154f		//地址值
		 System.out.println(arr[2]) ;//[I@70dea4e		//地址值
		 
		 System.out.println(arr[0][1]) ;
		 System.out.println(arr[1][1]) ;
	}
}

格式：

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

	二维数组的格式3:
		就是静态初始化
		数据类型[][] 数组名称 =
				new 数据类型[][]{{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
		简写格式:
	数据类型 [][] 数组名称 = {{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
				
		举例
			int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;
			
			-->简写格式
			int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;

举例：

class Array2Demo2{
	public static void main(String[] args){
		//格式2:
		int[][] arr = new int[2][] ;
		//二维数组中有2个一维数组,长度不知道,得动态给定长度
		System.out.println(arr) ;//二维数组的地址值[[I@十六进制数据  //[[I@6d06d69c
		
		//动态给定义2个一维数组的长度
		arr[0] = new  int[2] ; //第一个一维数组给定了2个长度
		arr[1] = new  int[3] ;//第二个一维数组给定了3个长度
		System.out.println(arr[0]) ; //[I@7852e922
		System.out.println(arr[1]) ;//[I@4e25154f
	}
}

遍历：

class ArrayTest{

	public static void main(String[] args){
		
		//定义一个二维数组:格式3静态初始化
		int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;
		
		//三个一维数组
		//第一个一维数组遍历
		for(int  x = 0 ; x < arr[0].length;x ++){
			System.out.print(arr[0][x]+" ") ;
		}
		System.out.println() ;
		
		//第二个一维数组遍历
		for(int  x = 0 ; x < arr[1].length;x ++){
			System.out.print(arr[1][x]+" ") ;
		}
		System.out.println() ;
		
		//第三个一维数组遍历
		for(int  x = 0 ; x < arr[2].length;x ++){
			System.out.print(arr[2][x]+" ") ;
		}
		System.out.println() ;
		
		//改进:其实上面代码:循环了3次---->3----就是二维数组的长度arr.length
        //二维数组的遍历
	
	    //外层循环:其实是一维数组的个数(arr.length)
	   //内层循环:其实每一个一维数组的长度(arr[x].length)
		for(int x = 0 ; x < arr.length; x ++){
			//每一个一维数组的内容
			for(int y = 0 ; y <arr[x].length; y++){
				System.out.print(arr[x][y]+" ") ;
			}
		}
		
		//变成功能----> 输出格式[元素1, 元素2, 元素3, 元素4...]
	
	}
	
}

5.方法的参数(基本数据类型、引用数据类型)

方法的形式参数分别是:基本数类型和引用类型之数组
	
	结论:
		1.形式参数如果是基本数据类型,形式参数改变对实际参数没有影响!
		2.形式参数如果是引用类型(数组,类,接口),形式参数的改变对实际参数有很大影响
		
		String是特殊的引用类型,它如果作为形式参数--->特点跟1_特点一样

举例：

class ArgsDemo{
	public static void main(String[] args){
		
		//定义两个变量
		int a = 10 ;	//String s1 = "hello" ;
		int b = 20 ;	//String s2 = "world" ;
		System.out.println("a:"+a+",b:"+b) ;//10,20
		change(a,b) ;
		System.out.println("a:"+a+",b:"+b) ;//10,20 
		
		int[] arr = {1,2,3,4,5} ; //new int[]{1,2,3,4,5};
		change(arr) ;
		System.out.println(arr[1]) ;
	}
	
	//形式参数是两个数据类型数据
	public static void change(int a,int b){ //实际参数赋值给形式参数
		System.out.println("a:"+a+",b:"+b) ;//10,20
			a = b ;
			b = a +b ;
		System.out.println("a:"+a+",b:"+b) ;//20,40
	}
	
	public static void change(int[] arr){
		//遍历
		for(int x = 0 ; x  < arr.length ; x ++){
			if(arr[x]%2 ==0){
				arr[x] *= 2 ;
			}
		}
	}
}

6.面向对象

面向对象的特点：

​ 封装、继承、多态

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

局部变量和成员变量的区别?

1.在类中的位置不同
    成员变量：在类中方法外
    局部变量：在方法内或者方法声明上的变量

2.在内存中的位置不同
	成员变量：在堆内存中存储   跟类有关
	局部变量：在内存中存储     跟方法有关
    
3.初始化时机不一样
    成员变量：跟对象有关，即使成员变量没有赋值，系统会根据变量类型对变量进行默认初始化
    局部变量：必须在使用之前对变量进行初始化，否则会报错
    
4.生命周期不同
    局部变量：随着方法的调用而产生，随着方法的结束而消失
	成员变量：随着对象的创建而存在，随后等待GC(垃圾回收器回收)回收

举例：

// 自定义一个类 
class Variable{
	
	//int num2 = 10 ;
	int num2 ; //系统默认初始化 0
	
	
	//show方法属于Variable类的成员方法  (以后说的方法:非静态方法)
	public void show(){
		//方法中定义
		int num = 100 ;
		System.out.println(num) ;
	//	int num ; //局部变量:必须使用之前赋值,否则报错!
		//System.out.println(num) ; // 可能尚未初始化变量num
	}
}
//测试类
class VariableDemo{
	public static void main(String[] args){
		//需求:要访问Variable类中的show方法
		//创建该类对:类名 对象名 = new  类名() ;
		//对象名.show();
		Variable v = new Variable() ;
		v.show() ;
		System.out.println(v.num2) ;//对象名.成员变量;
	}
}

8.形式参数

形式参数如果是一个基本数据类型,形参的改变对实际参数没有影响. 需要什么类型的数据,传递具体的值即可!
	
	形式参数如果是一个类(具体类),那么形式参数的改变直接影响实际参数!
	
		以后研究的引用类型
		结论:
			形式参数如果传递的是一个数组类型,需要传递的该数组的对象
			
			举例:
				//调用该方法的时候,形式参数要该数组对象 int[] arr = {1,2,3,4,5} ;
				public static void printArray(int[] arr){}
				
			形式参数如果传递的是一个具体类(jdk提供的,我们自定义的),需要传递该类的具体对象

举例：

class Student{
	public void study(){....}
}
class StudentDemo{
	public void method(Student s){  
//让你创建学生对象Student 对象名  = new Student();
		s.study() ;
	}
}
class Demo{
	//求两个数据之和的功能
	public int add(int a,int b){
		return a+b; 
	}
}
//定义一个学生类
class Student{
	//成员方法
	public void study(){
		System.out.println("Good Good Study ,Day Day Up!!!") ;
	}
}

//在定义一个类StudentMethod
class StudentMethod{
//成员方法:有一个形式参数:Student
	public void method(Student s){ //如果形式参数一个具体类,需要传递该类对象
//Student s  = new Student() ; s.study();
s.study() ; //s变量访问study() ---->需要学生类具体对象才能访问这个study()
	}
}

//测试类
class ArgsDemo{
	public static void main(String[] args){
		//需求:访问Demo类中的add方法
		//创建该Demo类的具体对象
		Demo d = new Demo() ;
		int result = d.add(10,20) ;
		System.out.println("结果是:"+result) ;
		System.out.println("--------------") ;
		//需求:要访问StudentMethod类中的method方法()
		//创建StudentMethod类的对象,使用对象调用method()
		StudentMethod sm = new StudentMethod() ;
	//	sm.method(Student s) ; sm.method(s) ;//找不到符号
		//需要创建一个学生对象
		Student student  = new Student() ;
		sm.method(student) ;//引用类型作为形参--->传递的是空间地址值!
		/*
			public void method(Student s){ //将学生对象传递进来student
							
					s.study() ;  //student.study() ;
			}
		*/
	}
}

9.匿名对象

定义：

​ 没有名字的对象

格式：

	new 类名();

特点：

特点:
		   1.仅仅使用一次,使用完毕,从内存中会立即被释放掉! (节省内存空间,android移动端使用居多!)
		   2.匿名对象也可以作为参数进行传递
		   
		  注意:
			在使用匿名对象的时候,建议不使用多次!

举例：

//自定义一个学生类
class Student{
	public void study(){
		System.out.println("好好学习,天天向上!!") ;
	}
}

//自定义StudentDemo类
class StudentDemo{
	public void method(Student s){//形式参数是一个引用类型,具体类
		s.study() ;
	}
}
//测试类
class NoNameDemo{
	public static void main(String[] args){
		//需求:访问StudentDemo类中的method方法
		//创建StudentDemo类对象                 类名 对象名 = new 类名() ;
		StudentDemo sd = new StudentDemo() ;
		//创建学生类对象
		Student s = new Student() ;   //对象名称叫s (有名称的对象)
		sd.method(s) ;
		System.out.println("-------------------------") ;
		
		//使用匿名对象
		sd.method(new Student()) ;  //该学生的匿名对象作为参数传递
		
		System.out.println("-------------------------") ;
		
		//链式编程(开发中不建议这样使用,阅读性差,建议分开写)
		new StudentDemo().method(new Student()) ;	
	}
}

10.封装

private关键字的特点：

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

举例：

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

11.this关键字

定义：

----为了区分成员变量和局部变量----java提供了一个关键字:this(代表了当前该类对象地址引用)
		
		setXXX(形参)方法,谁调用这个方法,那么this代表它(地址)

特点：(重点)

	//this.成员变量;  	  访问本类的成员变量
	//this.成员方法() 	  访问本类的成员方法
	//this() 			访问无参构造方法    访问本类的无参构造方法
	//this(xxx) ;   	访问带参构造方法    访问本类的有参构造方法

举例：

/定义一个学生类
class Student{
	//成员变量私有化
	private String name ; //姓名
	private int age; //年龄
	//提供公共的访问方法赋值 setXXX/getXXX方法 XXX对应的属性名称
	//给姓名赋值
	/*
	public void setName(String name){ 
		 name = name ; 
	}
	*/
	
	//改进
	public void setName(String name){ //"张三"
		this.name = name ;//this.name = "张三"
	}
	/*
	//给年龄赋值
	public void setAge(int age){ 
		age = age ;
	}
	*/
	public void setAge(int age){ // age = 25 局部变量
		this.age = age ; //this.age = 25
	}
	
	//获取姓名
	public String getName(){
		return name ; //此时获取的name,成员变量的name,隐藏关键了this
		//return this.name ; //其实这样的写法  //return "张三" ;
	}
	//获取年龄
	public int getAge(){ 
		return age ;// return this.age = return 25 ;
	}
	//其他的成员方法:
	public void study(){
		System.out.println("学习Java中的面向对象...") ;
	}
}
//测试类名
class StudentTest{
	public static void main(String[] args){
		//创建学生类对象
		Student s = new Student() ;
		//通过setXXX方法进行赋值 
		s.setName("张三") ;
		s.setAge(25) ;
		System.out.println(s.getName()+"---"+s.getAge());
		s.study();
	}
}

标准类格式：

一个标准类的写法:
			类{
				1)属性私有化
				2)提供对外的公共的setXXX(形式参数)/getXXX()方法
				3)构造方法:
				  永远给出无参构造方法;
				  有参构造
              }

标准类举例：

//定义学生类 
class Student{
	//属性私有化
	private String stuId ; //学号
	private String name ;  //姓名
	private int age ;      //年龄
	private String gender ; //性别
	
	//提供无参构造方法
	public Student(){
	}
	
	//提供有参构造方法
	public Student(String stuId,String name,int age,String gender){
		this.stuId = stuId ;
		this.name = name ;
		this.age = age ;
		this.gender = gender ;
	}
	
	//提供setXXX()/getXXX()
	public void setStuId(String stuId){
		this.stuId = stuId ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public void setGender(String gender){
		this.gender = gender ;
	}
	//获取值
	public String getStuId(){
		return stuId ;
	}
	public String getName(){
		return name ;
	}
	
	public int getAge(){
		return age ;
	}
	public String getGender(){
	
		return gender ;
	}
	
	public void study(){
		System.out.println("学习Java...") ;
	}
	public void sleep(){
		System.out.println("学习累了睡觉") ;
	}
	
}

//测试类
class StudentTest{
	public static void main(String[] args){
		//测试学生类
		
		//方式1:无参构造方法+setXXX:赋值
		Student s = new Student() ;
		s.setStuId("90077");
		s.setName("；李四");
		s.setAge(25) ;
		s.setGender("男") ;
		
		System.out.println(s.getStuId()+"----"+
		s.getName()+"----"+s.getAge()+"----"+
		s.getGender()); 
		s.study();
		s.sleep();
		System.out.println("--------------------------");
		//方式2:通过有参构造方法赋值  (构造方法目的:对对象的数据进行初始化)
		Student s2 = new Student("911","张三",29,"女") ;
		System.out.println(s2.getStuId()+"----"+
		s2.getName()+"----"+s2.getAge()+"----"+
		s2.getGender()); 
		
		s2.study();
		s2.sleep();		
	}
}

12.构造方法

定义：

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

举例：

//定一个学生类
class Student{
	
	//系统会给我们在类中提供一个无参构造方法
	public Student(){
		System.out.println("这是Student类的无参构造方法") ;
	}
	
	public void Student(){} //错误写法: 没有void 方法名和类名相同
	
}

//测试类
class ConstructorDemo{
	public static void main(String[] args){
		
		//创建一个学生对象
		Student s = new Student() ;
		System.out.println(s);//Student@十六进制数据
	}
}

注意事项：

构造方法中的注意事项:
			1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,
			
			2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!
					(永远建议给出无参构造方法)!

举例：

//老师类
class Teacher{

	//定义两个成员变量
	private String name ;
	private int age ;
	
	/*
		永远建议手动给出无参构造方法
	*/
	public Teacher(){
		System.out.println("手动给出了无参构造方法...") ;
	}
	
	
	//提供一个有参构造方法,带一个参数的字符串类型的
	public Teacher(String name){
		this.name = name ;//通过有参构造赋值 "张三"
		//System.out.println("这是带一个String类型参数的有参构造...") ;
	}
	//提供一个有参构造方法,带一个int类型参数的
	public Teacher(int age){
		System.out.println("这是带一个int类型的有参构造...") ;
	}
	
	public Teacher(String name,int age){
		System.out.println("这是一个带两个参数有参构造...") ;
	}
	
	//获取成员变量的值
	public String getName(){
		return name ;
	}
}
//测试类
class ConstructorDemo2{
	public static void main(String[] args){
		//通过无参构造方法创建对象
		//Teacher t = new Teacher() ;// 对于Teacher(没有参数), 找不到合适的构造器
		
		//提供无参构造方法:
		Teacher t = new Teacher() ;
		System.out.println(t);
		System.out.println("------------------------") ;
		//创建一个新的Teacher对象,通过带一个String类型的构造方法
		Teacher t2 = new Teacher("张三") ;
		System.out.println(t2.getName()) ;
		System.out.println(t2);
		System.out.println("------------------------") ;
		Teacher t3 = new Teacher(39) ;
		System.out.println(t3);
		System.out.println("------------------------") ;
		//给成员变量赋值:有参构造方法初始化
		//		setXXX(形参)
		Teacher t4 = new Teacher("张三",39) ;
		System.out.println(t4);
		
	}
}

13.成员方法

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

举例：

class StudentDemo{
	//定义成员方法
	
	//有返回来类型的情况
	
	//有返回值,带参
	public String method(String str){
		return "hello"+str;
	}
	
	//有返回值,不带参的
	public String function(){
		return "hello JavaEE" ;
	}
	
	//没有返回值类型的情况
	
	//没有返回值带参的 :void代替返回值类型
	public void  show(int num){
		System.out.println(num);
		function2() ;
	}
	
	//没有返回值,不带参的
	private void function2(){
		System.out.println("function2 StudentDemo") ;
	}
	
}
//测试类
class MethodDemo{
	public static void main(String[] args){
			//访问这些成员方法:
			//创建对象 :类名  对象名 = new 类名();
			StudentDemo sd = new StudentDemo() ;
			String result = sd.method("world") ;
			System.out.println(result) ;
			
			String s2 = sd.function() ;
			System.out.println(s2) ;
			
			sd.show(100) ;
			//sd.function2() ;//function2() 在 StudentDemo 中是 private 访问控制
			
	}
}

14.static关键字

内存图解:

静态static的特点:
		1)被static修饰的变量/方法   **随着类的加载而加载**
			
				class xxx{} ----> 通过javac 编译xxx.java文件		--->编译没有问题(Java语法校验)
							---->产生xxx.class文件   
							
								java xxx类
                    
		2)被static修饰的          **优先于对象存在**
                    
			main() :被静态修饰符: jvm调用它
				public static void main(String[] args){
					
				}
				
		3)被static修饰的可以被多个对象共用 
			有共享,共用
			
		4)被静态修饰的成员变量或者成员方法 ,
				可以被类名直接访问(推荐访问方式)
					类名.成员变量;
					类名.成员方法();
				
		注意:也可以用该类对象来访问该成员(不推荐!)

注意事项:

static关键字的注意事项:
	
		1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的和类有关系);
		2)关于成员方法的访问问题:

				非静态的成员方法
					既可以访问静态的成员变量,也可以访问非静态的成员变量
					既可以访问静态的成员方法,也可以访问非静态的成员方法;
				
				静态的成员方法
					记住:静态只能访问静态

什么时候定义局部变量什么时候定义成员变量:

问题:什么时候将变量定义为成员变量? 

	如果变量能够描述生活中事物的属性的话,这个时候将变量定义为成员变量;否则,就局部变量
	
	实际开发中,变量的范围越小越好 (局部变量)

15.文档注释

在ArrayDemo类中测试一个针对数组操作的工具类
	
	1)工具类ArrayTool---> 无参构造私有化了
	
	2)定义相关的功能(静态的功能)
	3)提供相关文档注释              格式:  /** 文档注释 */
	在类上以及方法上都需要加上文档注释
	
	4)针对ArrayTool工具类---->产生描述该类的文档 
			在dos中:javadoc -d 目录名字  -author -version ArrayTool.java

举例:

该类是自定义的针对数组操作的工具类
	@author apple
	@version V1.0
*/
public class ArrayTool{
	
	//无参构造私有化,目的:外界不能直接创建对象!
	private ArrayTool(){
	
	}
	
	/**
		该方法是针对数组遍历的功能,将数组以[元素1, 元素2, ..]该格式输出
		@param arr 需要被遍历的数组
	*/
	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] +", ") ;
			}
		}
	}
	/**
		该方法是获取数组中的最大值
		@param arr 在指定的数组中获取最大值
		@return 返回最大值
	*/
	public static int getMax(int[] arr){
		//定义参照物
		int max = arr[0] ;
		for(int x = 1 ; x < arr.length ; x ++){
			if(arr[x] > max){
				max = arr[x] ;
			}
		}
		return max ;
	}
	/**
		该方法是在指定的数组中查询指定元素角标值
		@param arr 在指定的数组中查询
		@param key 要查询的指定数组中元素
		@return 如果查找到了,返回该角标值,如果没有查找到,返回-1
	*/
	public static int getIndex(int[] arr,int key){
			//假设实现
			int index = -1 ;
			for(int x = 0 ; x < arr.length ; x ++){
				if(arr[x] == key){
				   index = x ;
				   break ;
				}
			}
			return index ;
	}
}

16.创建对象做了哪些事

内存图解:

1).加载Student.class

2).在栈内存空间中开辟栈内存空间

3).在堆内存中申请空间

4).对数据进行初始化(成员变量)
	4.1)系统默认初始化
	4.2)显示初始化--setXXX(形参)/构造方法赋值	
5)堆内存中申请空间完毕,产生一个堆内存地址

6)将堆内存地址赋值给栈内存变量

7)栈内存变量s指向的堆内存地址

16.创建对象做了哪些事

1).加载Student.class

2).在栈内存空间中开辟栈内存空间

3).在堆内存中申请空间

4).对数据进行初始化(成员变量)
	4.1)系统默认初始化
	4.2)显示初始化--setXXX(形参)/构造方法赋值	
5)堆内存中申请空间完毕,产生一个堆内存地址

6)将堆内存地址赋值给栈内存变量

7)栈内存变量s指向的堆内存地址