本文共 5829 字，大约阅读时间需要 19 分钟。

创建数组

创建数组，语法如下：

arrayRefVar = new dataType[arraySize];dataType[] arrayRefVar = new dataType[arraySize];dataType[] arrayRefVar = {
   value0, value1, ..., valuek};

例子：

public class TestArray {
      public static void main(String[] args) {
         // 数组大小      int size = 10;      // 定义数组      double[] myList = new double[size];      myList[0] = 5.6;      myList[1] = 4.5;      myList[2] = 3.3;      myList[3] = 13.2;      myList[4] = 4.0;      myList[5] = 34.33;      myList[6] = 34.0;      myList[7] = 45.45;      myList[8] = 99.993;      myList[9] = 11123;      // 计算所有元素的总和      double total = 0;      for (int i = 0; i < size; i++) {
            total += myList[i];      }      System.out.println("总和为： " + total);   }}

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。

public class TestArray {
      public static void main(String[] args) {
         double[] myList = {
   1.9, 2.9, 3.4, 3.5};       // 打印所有数组元素      for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");      }      // 计算所有元素的总和      double total = 0;      for (int i = 0; i < myList.length; i++) {
            total += myList[i];      }      System.out.println("Total is " + total);      // 查找最大元素      double max = myList[0];      for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max) max = myList[i];      }      System.out.println("Max is " + max);   }}/*以上实例编译运行结果如下：1.92.93.43.5Total is 11.7Max is 3.5

For-Each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

public class TestArray {
      public static void main(String[] args) {
         double[] myList = {
   1.9, 2.9, 3.4, 3.5};       // 打印所有数组元素      for (double element: myList) {
            System.out.println(element);      }   }}以上实例编译运行结果如下：1.92.93.43.5

int a[][] = new int[2][3];//二维数组 a 可以看成一个两行三列的数组。

Arrays 类 1 public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

import java.util.*;public class CommandPara {
   	 public static void main(String[] args) {
   		  int[] array1 = new int[]{
   1,2,3,4,5,10};	       int pos = Arrays.binarySearch(array1,1);	       System.out.println("Pos="+pos);	       pos =  Arrays.binarySearch(array1,10);	       System.out.println("Pos="+pos);	      	       int[] array2 = new int[]{
   10,1,2,3,4,5};	        pos = Arrays.binarySearch(array2,10);	       System.out.println("Pos="+pos);	       pos =  Arrays.binarySearch(array2,1);	       System.out.println("Pos="+pos);}}

2 public static boolean equals(long[] a, long[] a2)

如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

3 public static void fill(int[] a, int val)

将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

public class CommandPara {
   	public static void main(String[] args) {
   				int[] data = new int[]{
   1,2,3};			Arrays.fill(data, 6);			for (int k=0;k

4 public static void sort(Object[] a)

对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 Arrays.sort(a);

Java 继承

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。 extends：

public class Animal {
        private String name;       private int id;     public Animal(String myName, String myid) {
            //初始化属性值    }     public void eat() {
     //吃东西方法的具体实现  }     public void sleep() {
    //睡觉方法的具体实现  } }  public class Penguin  extends  Animal{
    }

implements ：

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
       public void eat();    public void sleep();} public interface B {
       public void show();} public class C implements A,B {
   }

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。 this关键字：指向自己的引用。

class Animal {
     void eat() {
       System.out.println("animal : eat");  }} class Dog extends Animal {
     void eat() {
       System.out.println("dog : eat");  }  void eatTest() {
       this.eat();   // this 调用自己的方法    super.eat();  // super 调用父类方法  }} public class Test {
     public static void main(String[] args) {
       Animal a = new Animal();    a.eat();    Dog d = new Dog();    d.eatTest();  }}输出结果为：animal : eatdog : eatanimal : eat

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写： final class 类名 {//类体} 构造器 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。 如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

class SuperClass {
     private int n;  SuperClass(){
       System.out.println("SuperClass()");  }  SuperClass(int n) {
       System.out.println("SuperClass(int n)");    this.n = n;  }}// SubClass 类继承class SubClass extends SuperClass{
     private int n;    SubClass(){
    // 自动调用父类的无参数构造器    System.out.println("SubClass");  }      public SubClass(int n){
        super(300);  // 调用父类中带有参数的构造器    System.out.println("SubClass(int n):"+n);    this.n = n;  }}// SubClass2 类继承class SubClass2 extends SuperClass{
     private int n;    SubClass2(){
       super(300);  // 调用父类中带有参数的构造器    System.out.println("SubClass2");  }      public SubClass2(int n){
    // 自动调用父类的无参数构造器    System.out.println("SubClass2(int n):"+n);    this.n = n;  }}public class TestSuperSub{
     public static void main (String args[]){
       System.out.println("------SubClass 类继承------");    SubClass sc1 = new SubClass();    SubClass sc2 = new SubClass(100);     System.out.println("------SubClass2 类继承------");    SubClass2 sc3 = new SubClass2();    SubClass2 sc4 = new SubClass2(200);   }}/*输出结果为：------SubClass 类继承------SuperClass()SubClassSuperClass(int n)SubClass(int n):100------SubClass2 类继承------SuperClass(int n)SubClass2SuperClass()SubClass2(int n):200

转载地址：http://ytcki.baihongyu.com/