Java基础教程

学习大纲：

面向过程，循环、分支、判断
面向对象，类，封装、继承、多态
注释、泛型及枚举

JAVA的用途

网页web开发及后台开发
大数据分析
Android应用开发
桌面GUI
软件开发
视频游戏开发

第一章面向过程

（1）整数类型：
最小整数类型是byte，它是有符号的8位类型，范围从-128~127.如byte b = 100;
其余常见的整数类型有：short、int、long。

（2）字符类型：
char类型用于存储字符，在JAVA中字符是用Unicode来编码的，所以插入类型可以试字符，也可以是数字，对应的Unicode表中的字符。
比如：char ch1 = 'Y';char ch2 = 89;

（3）算术、布尔、三元、关系运算符：
和c++一样。

（4）if、for、while、break、continue、注释语句
和c++一样

第二章面向对象

1、类

如下所示：

class Box {
    int width;
    int height;
    int depth;

    void take();
}//声明Box类

public class Main {
    public static void main(String args[]) {
    Box myBox = new Box();         //实例化
    myBox.width = 10;              //给width属性赋值
  }
}

其中Box即为声明的类，下面main方法中实例化，并给属性赋值。

（1）嵌套类

–JAVA匿名类

直接new对象，没有实际的类变量，形如下所示：

new Box(){
    xxxxxx....xxxx;
}.take();

（2）局部类

通俗点讲，就是类的方法里声明一个类，该类只能在改方法内使用，形如下所示：

class MyClass {
    void myMethod(final int x) {
    final int y = x;

    class LocalClass {
      int a = x;
      int b = y;
    }

    LocalClass lc = new LocalClass();
    System.out.println(lc.a);
    System.out.println(lc.b);
  }
}

（3）成员类

与局部类不同的是，成员类是作为大类的一个属性存在的，形如下所示：

class EnclosingClass {
  private int outerVariable;

  private void privateOuterMethod() {
    System.out.println(outerVariable);
  }

  class EnclosedClass {
    void accessEnclosingClass() {
      outerVariable = 1;
      privateOuterMethod();
    }
  }
}

（4）静态成员类

顾名思义，就是静态类型的成员类。

（5）抽象类

如下所示，是一个抽象类的具体应用

abstract class MyAbstractClass {
  abstract void callme();

  void callmetoo() {
    System.out.println("This is a concrete method.");
  }
}

class B extends MyAbstractClass {
  void callme() {
    System.out.println("B"s implementation of callme.");
  }
}

public class Main {
  public static void main(String args[]) {
    B b = new B();
    b.callme();
    b.callmetoo();
  }
}

解释：
抽象类是一种定义抽象概念的类，通常作为父类被子类继承。他可以定义抽象方法，也可以定义实体方法。需要注意的是，抽象方法是不能有实体实现过程的。其中extends代表着B类继承MyAbstractClass类，并具体实现了父类的抽象方法。

2、变量类型

（1）引用类型

如下所示：

Box b1 = new Box(); 
Box b2 = b1;

其中，**b1到b2的赋值没有分配任何内存或复制任何部分原始对象。它简单地使b2指向与b1相同的对象。因此，通过b2对对象所做的任何更改将影响b1所引用的对象。
对b1的后续赋值将简单地从原始对象中解除b1而不影响对象或影响b2**。（注意点1）

在参数传递时，引用类型参数在方法内被修改，在外面也是会被影响的。（注意点2）

（2）值类型

这个就比较简单了，你就是你，我就是我，互不干扰。

3、静态方法

需要注意的是，JAVA中的静态类只有静态内部类（嵌套类）。

静态方法有下面几个限制：
- 他们只能调用其他静态方法
- 他们只能使用静态变量
- 他们不能以任何方式引用

如下所示：

public class Main {
  static int a = 3;
  static int b;

  static void meth(int x) {
    System.out.println("x = " + x);
    System.out.println("a = " + a);
    System.out.println("b = " + b);

  }

  public static void main(String args[]) {
    Main.meth(42);
  }
}

第三章注释、泛型及枚举

1、注释

算是我接触JAVA以来的一大特色吧，尤其在用spring boot快速搭建JAVAweb项目时。在spring boot框架中大量使用注释来简化代码量。
具体使用如下：

 @MyAnno(str = "Annotation Example", val = 100)
 public static void myMeth(){xxxxx...xxxx}

具体使用还得查看具体的开发文档。

2、泛型

泛型和c#语言中的含义一样，反正刚开始接触有点蒙，说白了它就是一种代表着类型的变量。比如我们所知道的int变量代表的是整数，String变量代表的是字符串。
而泛型代表着的就是类型。如下所示：

// 在泛型类型中声明多个类型参数
class TwoGen<T, V> {
  T ob1;
  V ob2;
  TwoGen(T o1, V o2) {
    ob1 = o1;
    ob2 = o2;
  }
  void showTypes() {
    System.out.println("Type of T is " + ob1.getClass().getName());
    System.out.println("Type of V is " + ob2.getClass().getName());
  }

  T getob1() {
    return ob1;
  }

  V getob2() {
    return ob2;
  }
}

public class Main {
  public static void main(String args[]) {
    TwoGen<Integer, String> tgObj = new TwoGen<Integer, String>(88, "Generics");  //具体实例化，常用的是List<T>和Hash<T,V>
    tgObj.showTypes();
    int v = tgObj.getob1();
    System.out.println("value: " + v);
    String str = tgObj.getob2();
    System.out.println("value: " + str);
  }
}

3、枚举

优势在于定义枚举后，可以创建该类型的变量。即使枚举定义一个类类型，你不使用new实例化一个枚举。

如下所示：

// An enumeration of direction varieties. 
enum Direction {
  East, South, West, North
}

public class Main {
  public static void main(String args[]) {
    Direction dir = Direction.South;

    System.out.println("Value of dir: " + dir);

    dir = Direction.South;

    if (dir == Direction.South){
      System.out.println("ap contains GoldenDel.\n");
    }
  }
}