《菜鸟记基础篇5》——数组的小例题，方法的相互调用，静态块，游离块，static关键字，属性的访问器，封装

菜鸟记所有篇章都是个人随手记，可能存在知识点遗漏，请多包涵。
之后篇章的菜鸟记 概念居多。

---

一、数组小例题

利用二分查找法，查找数组的中的数据。

//利用二分查找法最重要的前提是 数组是有序的
  int[] arr= {1,2,3,4,5,6};

  int low = 0; //数组的起始下标
  int high = arr.length - 1;
  
  int key = 1;
   
  int middle = 0; 中间元素的下标
  
  while(low<=high){
  	 middle = (low + high)/2;
  	 if(arr[middle] < key){
  	 	low = middle + 1;
  	 }else if(arr[middle] > key){
  	 	high = middle - 1;
  	 }else{
  	 	break;
  	 }
  }
	
	if(low <= high){
		System.out.println(middle);
	} else{
		System.out.println(-1);
	}

二、类的组成详细

类的组成部分: 5
1.成员属性
2.方法 ， 函数
3.构造器:

构造器:
构造函数， 构造方法

语法结构：
pubilc 类名(参数列表){
//方法体
}

 1.属性 ： 成员属性 ，
     	 public 数据类型 变量名;
     	 
     	 Hero hero = new Hero();
		//当这个类 通过 javac 编译成 class ，java class ---> 将这个类的
		结构加载到 jvm 中， 他会自动初始化成员变量
		public class Hero{
			 public String name = "张三";
			 int age;
			 
		}     	 
  	    System.out.println(hero.name);
  	    System.out.println(hero.age);
     
     2.行为 ， 功能， （函数  ， 方法）	    
        1)无返回值 无参数
        	public void eat(){
        		 //方法体
        	}
        2)无返回值 有参数
        	public void eat(String food){
        		 
        	}
       	3)有返回值 无参数
        	public String eat(){
        		 return "面包";
        	}
        4)有返回值 有参数
  	 	    public String eat(int money){
  	 	    	 return "花了"+money+"元买了面包";
  	 	    }

1.构造方法和普通方法

1.1 构造方法是不是方法?

答： 是方法， 但是 是 特殊方法， 没有返回值

1.2 构造方法的作用是什么?

1、规范对象的创建
2、 给成员属性赋值

我们在创建类时，没有手动 创建构造方法， jvm虚拟机 会默认
给我们一个无参数的构造方法 ，供你使用

1.3方法的重载
在同一个类中，方法名相同，参数列表不同， 与返回值无关
这种现象 被称为 方法的重载 （构造方法， 普通方法）

不同: 参数顺序， 类型， 个数 的不同
1.4 java中 给 属性赋值:
1. = 等号赋值
2.构造方法赋值

1.5 类中有两种方法:
1.普通方法: 这个类的功能;
2.构造方法： 给这个类创建对象， 给属性赋值

1.6 方法的相互调用:
1.普通法的相互调用:
在代码的任何地方 调用对方的 方法名(); 即可

2.构造方法的相互调用:
必须在方法体 的第一行， 用this(); 表示

2.类的 组成包含的知识点:

类的 组成部分:
1.成员属性
2.普通方法
3.构造方法

4.构造块儿， 游离块儿

5.静态块儿 ： static

作用:
 1)static可以修饰属性， 通过static修饰的属性，被修饰的属性
 	 是静态属性， 可以通过类名.属性名   调用,而且 只被加载一次;

 2)static可以修饰普通方法， 被static修饰的方法是 ，静态方法
   	可以通过类名.方法名(); 调用执行
  
 3)static 还可以修饰类 (内部类  : 就是一个类 包含了一类 )
  	  	  例如 : 
  	 public class Cat{ 	  
  	  	    //内部类
		static class SmallCat{
			作用: 为了 更好的封装
		}	  
	 }
	 ***静态方法中 必须加载 静态资源(静态属性和 静态方法)	 
      非静态方法 可以加载 静态资源
	 
游离块儿: 
   语法结构: {     }
  	游离块 永远都比 构造方法  优先执行，
  	一个类中可以有多个 游离块儿 ， 他们会根据 类中的顺序 依次执行
  
 静态块儿:  作用大
    语法结构:
     static{
     	
     }
     
   静态块儿 永远比游离块儿 优先执行  

  static: 可以修饰 属性， 可以修饰普通方法， 不能修饰 构造方法
  	  	  还可以修饰类 (内部类 一个类 包含了一类 )
  	  	  例如 : 
  	 public class Cat{ 	  
  	  	    //内部类
		static class SmallCat{
			作用: 为了 更好的封装
		}	  
	}