第二篇

数组的操作：
 (1)查找
  A：无序数组
  遍历

  B：有序数组 二分查找
  数组长度是6,最大角标值是5
  public static int getIndex(int[] arr,int key) {
   int min = 0;
   int max = arr.length-1;
   int mid = (min + max)/2;
   while (key != arr[mid]){
    if (key > arr[mid]){
     min = mid + 1;
    }else if (key < arr[mid]){
     max = mid - 1;
    }
    if (min > max){
     return -1;
    }
    mid = (min + max)/2;
   }
   return mid;
   
  }
  
 (2)数组反转
 要求:给一个数组让其反转,而并不是反过来遍历
 public static void main(String[] args) {
  int[] arr = {3,2,1,5,4,6};//6,4,5,1,2,3;
  revArray(arr);
  System.out.println(print(arr));
  Arrays.
 }
 
 //定义反转的方法,经过分析我们发现需要对调的角标是两个变化的变量
 //第一次让头角标和尾角标对调,然后让头角标自增,尾角标递减再对调
 public static void revArray(int[] arr) {
   //int start = 0;
   //int end = arr.length-1;
   for (int start=0,end = arr.length-1;start<end ;start++, end--){
    //角标值每变化一次就对调一次
    int temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;
  }
  
 }

 //把数组转换成字符串输出,因为任何数据类型与字符串用+想连接都会产生新的字符串
 int [] arr = {6,5,4,3,2,1};[6,5,4,3,2,1]
 public static String arrToString(int[] arr) {
  String str = "[";
  for (int x = 0; x < arr.length; x++){//[6,5,4,3,2,
   if (x != arr.length - 1) {
    str = str + arr[x] + ",";
   }else {
    str = str + arr[x] +"]";
   }
  }
  return str;
 }

 (3)一维数组的应用
 查表法
 
 public static void main(String[] args) {
  toHex(60);
 }

 public static void toHex(int num) {
  /*经过我们分析发现任何数与上15的结果肯定在0到15之间,这些元素是固定的
  那么我们就有了这样的一个想法,把所有的元素定义在一个表里,然后我们通过角标去
  访问这个对应的元素,请看下表
  {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15
  看过这个表后,我们发现,0-15角标对应的值就是十六进制里面所有的元素,刚才我们分析任何数与上15
  的结果就是在0到15之间,所以我们把这个结果当作角标值,去表中查找对应的元素即可
  */

  //定义一个表,十六进制里面的元素分别是0-15
  char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  //             0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15
  
  //定义一个数组,目的是把每次这个数与完15后的值,进行存储
  char[] arr = new char[8];

  //定义一个指针,用于操作数组
  int pos = arr.length-1;
  if (num == 0){
   System.out.println(num);
   return;
  }
  //当num不等于0的时候我们就让这个数不断与上15,和不断的想右移动四位
  while (num != 0){
   //每次的值需要存储在不同角标的位置上,所以指针的指向需要改变
   
   //用一个变量记录住这个数与上15的结果
   int temp = num & 15;//3
   //temp里面记录的结果肯定是在0到15之间,所以把temp当作定义表的角标值去找对应的元素
   //然后赋值到定义的数组中存储
   arr[pos] = chs[temp];//
   //上述操作是获取一个int数的32个二进制位的最低的四位,为了获取下一个有效四位
   //让这个数再向右移动四位
   pos--;
   num = num >>> 4; 
  }
  
  //把新的数组进行遍历输出,为了可以从头输出,不要前面的那些空位,我们把第一次遍历的位置定义的不是
  //零,而是pos指针所指向的位置
  for (int x=pos+1;x < arr.length ;x++ ){
   System.out.print(arr[x] + "");
  }
 }

 

  
2：二维数组
 (1)int[][] arr = new int[3][2];arr[1][0]
  A：定义了名称为arr的二维数组
  B：二维数组中有3个一维数组
  C：每一个一维数组中有2个元素
  D：一维数组的名称分别为arr[0], arr[1], arr[2]
  arr[0][0] arr[0][1]
  arr[1][0] arr[1][1]
  arr[2][0] arr[2][1]
  arr:二维数组名
  arr[1]:二维数组中的第二个一维数组名
  arr[1][1]:二维数组中的第二个数组的第二个元素
  E：给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
 (2)格式2：int[][] arr = new int[3][];
  A: 二维数组中有3个一维数组
  B: 每个一维数组都是默认初始化值null
  C: 可以对这个三个一维数组分别进行初始化
    arr[0] = new int[3];
    arr[1] = new int[5];
    arr[2] = new int[7];
 (3)int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};arr[2].length
  A：二维数组有3个一维数组。
  B：第一个一维数组有3个元素
     第二个一维数组有2个元素
     第三个一维数组有4个元素
 (4)二维数组的遍历
  
 (5)二维数组的应用
  求一年的销售总额。
  public static void printArray2(int[][] arr2){
   int sum = 0;
   for(int i=0; i<arr2.length; i++){
    for(int j=0; j<arr2[i].length; j++){
     sum = sum + arr[i][j];
    }
    System.out.println("sum =" + sum);
   }
  }
  
 
 int[] y, x[];
 int[] y;一维数组
 int[] x[];二维数组
 (a) x=y; no
 (b)x[0]=y; yes
 (c)x[0] = y[0];//no
 (d)x = y[0]; //no
 (e)x[0][0] = y[0];yes
面向对象
 (1)面向过程 强调过程，执行者
 (2)面向对象 强调对象，指挥者
 (3)面向对象思想的特点
  A：它是一种更符合人们思考习惯的思想
  B：它是复杂的内容简单化
  C：它使我们从执行者变成了指挥者
 面向对象的思想
 定义一：面向对象方法是一种运用对象、类、封装、继承、多态和消息等概念来构造、测试、重构软件的方法。
 定义二：面向对象方法是以认识论为基础，用对象来理解和分析问题空间，并设计和开发出由对象构成的软件系统
 （解空间）的方法。 由于问题空间和解空间都是由对象组成的，这样可以消除由于问题空间和求解空间结构上的不
 一致带来的问题。简言之，面向对象就是面向事情本身，面向对象的分析过程就是认识客观世界的过程。
 面向对象方法从对象出发，发展出对象，类，消息，继承等概念。
 面向对象方法的主要优点是：符合人们通常的思维方式；从分析到设计再到编码采用一致的模型表示具有高度连续性；
 软件重用性好。
 (4)面向对象的特点
  A：封装
  B：继承
  C：多态

类和对象         
 (1)类 对现实世界中事物的描述(属性和方法)Person p = new Person();
 (2)对象 现实世界中实际存在具体的个体
 (3)对象的使用以及内存图 new
 

局部变量和成员变量
 (1)作用范围
  局部变量：方法内
  成员变量：类中，对整个类有效{成员变量分为两种一种静态的,一种非静态的}
 (2)存储空间
  局部变量：栈内存
  成员变量：堆内存{静态的成员变量在方法区,非静态的在对象中在堆内存中}
 (3)初始化值
  局部变量：在使用前必须手动给值
  成员变量：jvm默认初始化值。int 0 byte 0 short 0 long 0 double 0.0 boolean false float f = 100

  

匿名对象的使用(了解)
 (1)当对对象中的功能只执行一次的时候使用。否则，请你使用有名字的对象。
 (2)用于作为实际参数进行传递。
 (3)不可以用匿名对象调用属性

封装
 (1)封装的好处：便于重复使用，安全性高。
 (2)private权限修饰符
  
构造函数
 class Person{
  int age;
  Person(int age){}
 }
 (1)用途：用于给对象中属性进行初始化。
  A：格式类名(){code}Person(){}
  B：Person(){}public Person(){}
 (2)特点 你不定义空参数的构造函数，系统会自动给一个空参构造，你定义了构造函数无论是有参还空参的，
  系统就不再给空参数的了。
 (3)重载构造函数,是根据参数列表来区分是哪个构造函数
  A：Person(){}//Person p = new Person();
  B：Person(int age,String name){}
  C：Person(int age){}
  D：Person(String name,int age){}

 注意：构造还可以用于给属性赋值。

this关键字
 什么时候使用this
  A：当局部变量和成员变量重名的时候,可以用this进行区分。
  B：写功能的时候，可能用到this。比如比较两个对象的年龄compare()
  C：构造函数中使用this
   **this() 必须放在第一行。
  
  
代码块
 (1)局部代码块 控制变量的生命周期{int x}
 (2)构造代码块 每创建一次对象就执行一次。
 (3)思考下面的问题
  Person p = new Person();
  它在内存中做了哪些事情？
  A：将Person.class文件加载到内存中。
  B：在栈内存中声明Person类型的变量P。
  C：在堆内存中创建一个对象Person。分配地址值
  D：把Person中的属性进行默认初始化。
  E：把Person中的属性进行显示初始化。
  F：调用构造代码块(如果没有，不执行这个操作)。
  G：调用构造函数进行初始化。
  H：把堆内存的地址(引用)赋给了栈内存中P。

  
static关键字
 (1)静态的意思。可以修饰类的成员(成员变量和成员方法);
 (2)静态成员的特点：
  A：随着类的加载而加载，生命周期最长。
  B：优先于对象存在。javac Demo 生成Demo.class java Demo{ Demo d = new Demo();
  }
  C：被所有的对象所共享。
  D：比非静态成员多了一种访问方式。可以通过类名直接调用。建议用类名.调用
 (3)什么时候需要使用static修饰呢？
  当类中的成员需要被所有对象共享时，用static修饰。不需要被共享时，就不用static修饰。
  简单说：共性用static修饰，特性不用static修饰。
 (4)注意事项
  A：静态方法只能访问静态成员的。
  B：静态方法中不能使用this,super关键字。
  C：main是静态的。
   **格式如下：
   public static void main(String[] args){//new String[0]
   }

     ***由于它被jvm调用，所以权限要足够大，所以用public权限修饰符。
     ***为了jvm可以不用创建对象直接调用它，所以用static修饰。
     ***void jvm不需要任何返回。但是方法体结尾默认有return;
     ***main jvm只认识这个名字。
     ***String[] 有可能需要传入参数。
     ***args 字符串数组的名字,只要符合标识符的命名规则可以随便起。
 (5)静态代码块
  类中加载流程？
  静态代码块--构造代码块--构造方法。

2：静态的应用
 工具类ArrayTool
 因为使用的都是class文件。所以你应该先编译ArrayTool，然后在编译ArrayToolDemo，最后执行ArrayToolDemo。
 但是如果引用的工具类特别多的情况下，这样就很麻烦，所以java提供好的方式：只编译ArrayToolDemo即可。
 (其实它首先在classpath下找ArrayTool.class，如果没有，接下来在当前类下找ArrayTool.class文件。
  如果还没有，它就会找ArrayTool.java文件，并且进行编译。如果都没有，就报错。)

  制作工具说明书:代码中有文档注释,用javadoc解析。
  javadoc -d myAPI -author -version ArrayTool.java
  -d 后面跟目录
  ArrayTool.java 源代码文件

  javadoc: 错误 - 找不到可以文档化的公共或受保护的类。
  改用public修饰一下即可

3：API(Application programming Interface)：应用程序编程接口。
 JavaAPI:java的帮助文档。

4：设计模式
 java中有23种设计。

 单例设计模式：保证类在内存中只有一个对象。
 
 如何保证类在内存中只有一个对象呢？
 (1)控制类的创建，不让其他类来创建本类的对象。private
 (2)在本类中定义一个本类的对象。Single s;
 (3)提供公共的访问方式。  public static Single getInstance(){return s}

 单例写法两种：
 (1)饿汉式 开发用这种方式。
 
 (2)懒汉式 面试写这种方式。多线程的问题？
 
继承(extends)
 (1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。
  **要了解这个体系结构中最共性的内容,就看最顶层的类。
  **要使用这个体系的功能,就用最底层的类创建对象。
 (2)继承的好处：
  A：继承的出现，提高了代码的复用性。
  B：继承的出现，让类与类之间产生了关系，extends来表示，
     这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。
 (3)特点
  A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。
  B：java支持多重(层)继承。
 (4)注意：
  A：子类可以直接访问父类中的非私有的属性和行为。
  B：不要仅为了获取其他类中部分功能而去继承。
  C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
   **如何判断A和B是否有继承关系？
   **A如果继承B，那么就可以说A是B的一种。

继承后子父类之间成员的关系
 (1)成员变量
  
 当局部变量和成员变量重名的时候用this来区分
    
 当子类和父类出现了同名变量,用super来区分
    
总结:在一个类中如果方法中的局部变量和方法外的成员变量重名,那么如果在方法内输出这变量,就是方法
     自己的变量里的值,想要区分要用this,加上this.就是输出成员变量的值
     在子父类中如果出现成员变量重名的时候,在子类输出会输出自己的变量里的值,想要区分要用super,
     加上super.就是输出父类里变量的值

      this和super的区分：
        **this代表本类对象的引用
      super本类对象父类的引用。
        **this可以用于区分局部变量和成员变量同名的情况。
      super可以用于区分子类和父类成员变量同名的情况。
        **一般，子类中不会出现和父类同名的成员变量。面试可能问到。

 (2)成员方法
  
  子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。
  重写(override)和重载(overload)的区别：
  重载的特点：
  **在同一类中。
  **方法名相同，参数列表不同。
  重写的特点：
  **要有继承关系。在子父类中
  **方法的声明相同。(方法名和参数列表都相同)
  ***覆盖时，子类方法权限一定要大于等于父类方法权限
  父类的权限不能是私有的
  ***静态只能覆盖静态。
 (3)构造方法
  总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。
   **因为每一个构造方法的第一行都有一条默认的语句super();

        当父类中没有空参数的构造方法时，子类的构造函数必须通过this
        或者super语句指定要访问的构造方法。或者手动提供无参构造方法。

        this(...):调用本类中的构造方法
        super(...):调用父类中的构造方法

  构造方法用于创建对象，并进行初始化.建议如果你写了有参的构造函数,也要把空参的构造函数再手动加上
  否则你定义了有参的构造函数,空参的系统就不会再给了
  你这样创建对象的时候就会报错Person p = new Person();//这句话是会去找空参的构造函数
  
  系统默认给出无参构造
                当你手动给出构造方法后，系统就不会再给出默认的空的构造方法。
  手动无参数，如果你想给属性赋值或者做一些初始化，无参你别删不就行了吗。
   

final可以用来修饰什么呢？
 (1)final可以用来修饰类：被fainl修饰的类不能被继承。
 (2)final可以用来修饰成员方法：被final修饰的成员方法不能被重写。
 (3)final可以用来修饰变量：被final修饰的变量为常量，值不能被修改。
    常量的命名规范：要求大写。
    final int PI = 3.14;

    final难道必须声明的时候就赋值。
    一般来说，是这样的。但是特殊情况：在构造方法可以给final修饰的变量赋值。
抽象类(abstract)
 (1)只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。
 (2)抽象类的特点
  A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方法。
  B：抽象类是不能够被实例化的。不能够创建对象的。
  C：如果一个类继承抽象类，那么，它要么重写抽象类中的所有抽象方法，要么本身也是抽象类。
 (3)抽象类的成员特点：
  A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)
  B：成员方法：抽象类中分为两种方法，一种是抽象方法，这种方法在子类中必须要被实现。一种是普通的方法。可以被子类直        接继承使用。
  C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。它的构造方法有用吗？ ，       为了让子类实例化的时候使用。
 (4)抽象类的相关问题： 
  A：抽象类中是否有构造函数？参照(3)里面的C。
  B：抽象关键字abstract不可以和哪些关键字共存？
   **private
    ***私有的，外部直接无法访问。
   **static
    ***那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。
   **final
    ***final修饰的方法不能被重写。所以它和abstract冲突。
  C：抽象类中可不可以没有抽象方法？
   **可以。如果这么做只有一个目的不让你创建这个类的对象
面向对象
   1：解释面向对象思想
   2：封装 private
   3：局部变量和成员变量
   4：构造 this
   5：继承 extends, super
   6：抽象类 abstract

  ***类，抽象类，还是接口。
  ***构造方法
  ***学习里面的功能。
  奉劝大家:学习程序要结合着生活中的例子去理解,不要就在程序中死扣,这样反而让你越来越越晕,比如理解
  继承有父亲有儿子,儿子从父亲那里继承非私有的东西很正常