java入门概念梳理总结

Java入门学习

简介

public class HelloWorld {
    public static void main(String []args) {
        System.out.println("Hello World");
    }
}
//输出
    // javac将java源文件编译为class字节码文件
$ javac HelloWorld.java
    // java后边执行的是java文件的类名，如HelloWorld，注意不要家后缀
$ java HelloWorld
Hello World

• Java分三个体系
  • JavaSE（J2SE/JavaEE）（Java2 Platform Standard Edition，java平台标准版）
  • JavaEE(J2EE/JavaEE)(Java 2 Platform,Enterprise Edition，java平台企业版)
  • JavaME(J2ME/JavaME)(Java 2 Platform Micro Edition，java平台微型版)。
• 特性
  • 简单：和C近，丢弃操作符重载，多继承，自动的强制类型转换，不适用指针而是引用，自动GC
  • OOP: 提供类，接口和集成，只支持类间继承，支持接口之间多继承并支持类与接口之间的实现机制。
    
    全面支持动态绑定。纯OOP。
  • 分布式的：支持Internet应用开发，在基本Java应用编程接口中有java net
    
    ,提供了网络应用变成的类库，包括URL,URLConnection,Socket,ServerSocket等
  • 健壮的：强制型机制、异常处理、垃圾回收，丢弃指针。
  • 安全的：通过网络下载的类具有一个安全防范机制
  • 体系结构中立
  • 可移植的
  • 解释型的
  • 高性能的
  • 多线程的
  • 动态的

基础语法

java程序可认为一系列对象的集合

• 对象： 类的一个实例，有状态和行为。
• 类： 类的一个模板，描述一类对象的行为和状态。
• 方法：行为
• 实例变量：每个对象都有独特的实例变量，对象的状态由此决定

基本语法

• 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

标识符：类名、变量名以及方法名都被称为标识符

修饰符：修饰类中方法和属性

• 访问控制修饰符 : default, public , protected, private
• 非访问控制修饰符 : final, abstract, strictfp

变量

• 局部变量
• 类变量（静态变量）
• 成员变量（非静态变量）

数组：储存在堆上的对象，可以保存多个同类型变量

枚举： 枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

注释同JS

继承::::被继承的类称为超类（super class），派生类称为子类（subclass）。

接口：对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

Java 对象和类

Java作为一种面向对象语言。支持以下基本概念：

• 多态
• 继承
• 封装
• 抽象
• 类

public class Dog{
  String breed;
  int age;
  String color;
  void barking(){
  }

  void hungry(){
  }

  void sleeping(){
  }
}

• 对象

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name );
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

• 实例

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name );
   }

   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("小狗的年龄为 : " + puppyAge );
       return puppyAge;
   }

   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPuppy.puppyAge );
   }
}

• 方法

public class Puppy{
    public Puppy(){
    }

    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

• 重载

Java packages:对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

Import 语句：提供一个合理的路径，使得编译器可以找到某个类。

基本数据类型

• 内置数据类型(8种)

• byte：

  • byte数据类型是8位、有符号的，以二进制补码表示的整数；
  • 最小值是-128（-2^7）；
  • 最大值是127（2^7-1）；
  • 默认值是0；
  • byte类型用在大型数组中节约空间，主要代替整数，因为byt- e变量占用的空间只有int类型的四分之一；
  • 例子：byte a = 100，byte b = -50。

• short：

  • short数据类型是16位、有符号的以二进制补码表示的整数
  • 最小值是-32768（-2^15）；
  • 最大值是32767（2^15 - 1）；
  • Short数据类型也可以像byte那样节省空间。一个short变量- 是int型变量所占空间的二分之一；
  • 默认值是0；
  • 例子：short s = 1000，short r = -20000。

• int：

  • int数据类型是32位、有符号的以二进制补码表示的整数；
  • 最小值是-2,147,483,648（-2^31）；
  • 最大值是2,147,483,647（2^31 - 1）；
  • 一般地整型变量默认为int类型；
  • 默认值是0；
  • 例子：int a = 100000, int b = -200000。

• long：

  • long数据类型是64位、有符号的以二进制补码表示的整数；
  • 最小值是-9,223,372,036,854,775,808（-2^63）；
  • 最大值是9,223,372,036,854,775,807（2^63 -1）；
  • 这种类型主要使用在需要比较大整数的系统上；
  • 默认值是0L；
  • 例子： long a = 100000L，Long b = -200000L。

• float：

  • float数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  • float在储存大型浮点数组的时候可节省内存空间；
  • 默认值是0.0f；
  • 浮点数不能用来表示精确的值，如货币；
  • 例子：float f1 = 234.5f。

• double：

  • double数据类型是双精度、64位、符合IEEE 754标准的浮点数；
  • 浮点数的默认类型为double类型；
  • double类型同样不能表示精确的值，如货币；
  • 默认值是0.0d；
  • 例子：double d1 = 123.4。

• boolean：

  • boolean数据类型表示一位的信息；
  • 只有两个取值：true和false；
  • 这种类型只作为一种标志来记录true/false情况；
  • 默认值是false；
  • 例子：boolean one = true。

• char：

  • char类型是一个单一的16位Unicode字符；
  • 最小值是’\u0000’（即为0）；
  • 最大值是’\uffff’（即为65,535）；
  • char数据类型可以储存任何字符；
  • 例子：char letter = ‘A’。

• 引用数据类型

  • 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量 声明时被指定为一个特定的类型，比如Employee、Pubby等。变量一旦声明后，类型就不能被改变了。
  • 对象、数组都是引用数据类型。
  • 所有引用类型的默认值都是null。
  • 一个引用变量可以用来引用与任何与之兼容的类型。
  • 例子：Site site = new Site("Runoob")。

• Java常量

• 自动类型转换：整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

• 强制类型转换：

  1. 条件是转换的数据类型必须是兼容的。
  2. 格式：(type)value type是要强制类型转换后的数据类型 实例：

public class QiangZhiZhuanHuan{
        public static void main(String[] args){
            int i1 = 123;
            byte b = (byte)i1;//强制类型转换为byte
            System.out.println("int强制类型转换为byte后的值等于"+b);

        }
    }

• 隐含强制类型转换
  1. 整数的默认类型是 int。
  2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f

Java变量类型

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

Java语言支持的变量类型有：

• 局部变量
  
  局部变量声明在方法、构造方法或者语句块中；
  
  局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
  
  访问修饰符不能用于局部变量；
  
  局部变量只在声明它的方法、构造方法或者语句块中可见；
  
  局部变量是在栈上分配的。
  
  局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
• 成员变量
  
  实例变量声明在一个类中，但在方法、构造方法和语句块之外；
  
  当一个对象被实例化之后，每个实例变量的值就跟着确定；
  
  实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
  
  实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
  
  实例变量可以声明在使用前或者使用后；
  
  访问修饰符可以修饰实例变量；
  
  实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
  
  实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
  
  实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
• 类变量
  
  类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
  
  无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
  
  静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
  
  静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
  
  静态变量在程序开始时创建，在程序结束时销毁。
  
  与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
  
  默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
  
  静态变量可以通过：ClassName.VariableName的方式访问。
  
  类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

Java修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端

public class className {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

• 访问修饰符

修饰符	当前类	同一包内	子孙类	其他包
public	Y	Y	Y	Y
protected	Y	Y	Y	N
default	Y	Y	N	N
private	Y	N	N	N

• 非访问修饰符
  • static 修饰符，用来创建类方法和类变量。
    • 静态变量：
      
      static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
    • 静态方法：
      
      static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
  • final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
    • final 变量：
      
      final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。
      
      final 修饰符通常和 static 修饰符一起使用来创建类常量。
    • final 方法
      
      类中的 final 方法可以被子类继承，但是不能被子类修改。
      
      声明 final 方法的主要目的是防止该方法的内容被修改。
    • }
      
      final 类
      
      final 类不能被继承，没有类能够继承 final 类的任何特性。
  • abstract 修饰符，用来创建抽象类和抽象方法
    • 抽象类：
      
      抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
      
      一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
    • 抽象方法
      
      抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
      
      抽象方法不能被声明成 final 和 static。
      
      任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
      
      如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
      
      抽象方法的声明以分号结尾，例如：public abstract sample();。
  • synchronized 和 volatile 修饰符，主要用于线程的编程。
    • transient 修饰符
    • volatile 修饰符
      
      volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
      
      一个 volatile 对象引用可能是 null。

Java运算符

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

Java循环结构

• while 循环
• do…while 循环
• for 循环
  • Java 增强 for 循环

     {
        //代码句子
     }
  

• break 关键字
• continue 关键字

Java分支结构

• if 语句
• switch 语句

Java Number&Math类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

Math类同JS

Java Character类

Character 类用于对单个字符进行操作。Character 类在对象中包装一个基本类型 char 的值

char ch = 'a';

// Unicode 字符表示形式
char uniChar = '\u039A'; 

// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

Java String类

Java StringBuffer类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

Java Array

声明数组变量

dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法

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

Java Date(same as JS)

Java RegExp(same as JS)

Java Method

System.out.println()，那么它是什么呢？
println() 是一个方法。
System 是系统类。
out 是标准输出对象。
这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;

   return result;
}
//调用
int larger = max(30, 40);

• void关键字

一个void方法的调用一定是一个语句。 所以，它被在main方法第三行以语句形式调用。就像任何以分号结束的语句一样。

• 通过值传递参数:调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。
• 重载(JS没有重载但可以模拟)：一个类的两个方法拥有相同的名字，但是有不同的参数列表
  
  Java编译器根据方法签名判断哪个方法应该被调用。

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

• 变量作用域：程序中变量可以被引用的部分。

方法的参数范围覆盖整个方法，参数即局部变量，for循环内生命的变量范围从其生命到循环体结束，这点与JS不同

• 命令行参数的使用。

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

命令行参数是在执行程序时候紧跟在程序名字后面的信息。

• 构造方法::::当一个对象被创建时，构造方法用来初始化该对象，构造方法和它所在类的名字相同，
  
  但没有返回值。

// 一个简单的构造函数
class MyClass {
  int x;

  // 以下是构造函数
  MyClass(int i ) {
    x = i;
  }
}
//你可以像下面这样调用构造方法来初始化一个对象：
public class ConsDemo {
  public static void main(String args[]) {
    MyClass t1 = new MyClass( 10 );
    MyClass t2 = new MyClass( 20 );
    System.out.println(t1.x + " " + t2.x);
  }
}

• finalize方法:在对象被回收前调用，用于清除回收对象。

//你必须指定在对象销毁时候要执行的操作,finalize() 一般格式是：
protected void finalize()
{
   // 在这里终结代码
}
public class FinalizationDemo {
  public static void main(String[] args) {
    Cake c1 = new Cake(1);
    Cake c2 = new Cake(2);
    Cake c3 = new Cake(3);  

    c2 = c3 = null;
    System.gc(); //调用Java垃圾收集器
  }
}  

class Cake extends Object {
  private int id;
  public Cake(int id) {
    this.id = id;
    System.out.println("Cake Object " + id + "is created");
  }  

  protected void finalize() throws java.lang.Throwable {
    super.finalize();
    System.out.println("Cake Object " + id + "is disposed");
  }
}

Java Stream,FIle , IO

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

//读取控制台输入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//从控制台读取多字符输入
int read( ) throws IOException

• 文件读写
  
  

Java Scanner类:获取用户的输入

import java.util.Scanner; 

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("next:");
        if(scan.hasNext()){
          String str1 = scan.next();
          System.out.println("input :"+str1);
        }
    }
}

Java unExpect

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的

常见三种异常

• 检查型异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，
  
  一个异常就发生了，这些异常在编译时不能被简单地忽略。
• 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
• 错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，
  
  一个错误就发生了，它们在编译也检查不到的。

Exception类的层次

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

---

OOP

Java 继承(基于类不如JS的基于原型)

• 类的继承

class Parent{

}
class Child extends Parent{
}
//动物类
public class Animal {
    private String name;
    private int id;
    public Animal(String myName, int myid) {
        name = myName;
        id = myid;
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() {
        System.out.println("大家好！我是"         + id + "号" + name + ".");
    }
}
//Penguin
public class Penguin extends Animal {
    public Penguin(String myName, int myid) {
        super(myName, myid);
    }
}
//Mouse
public class Mouse extends Animal {
    public Mouse(String myName, int myid) {
        super(myName, myid);
    }
}

• 继承特性：

  • 子类拥有父类非private的属性，方法。
  • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
  • 子类可以用自己的方式实现父类的方法。
  • Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，
    
    例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）

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

  • extends: 只能继承一个类。
  • implements:可以同时继承多个接口（接口跟接口之间采用逗号分隔）

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

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

    public class SuperDemo {
        public static void main(String []args) {
            new SubClass().showMessage();
        }
    }
  
    class SuperClass {
        int i = 50;
    }
  
    class SubClass extends SuperClass {
        int i =100;
        public void showMessage() {
            System.out.printf("super.i = %d, this.i = %d\n", super.i, this.i);
        }
    }
  

  • final:把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写

• 构造器：
  
  子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，
  
  则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
  
  如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，
  
  如果没有使用super关键字，系统会自动调用父类的无参构造器。

Java Override(重写)/Overload(重载)

Override

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，

但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法

      b.move();//执行 Dog 类的方法
   }
}
//
动物可以移动
狗可以跑和走

• 重写规则
  • 参数列表必须完全与被重写方法的相同；
  • 返回类型必须完全与被重写方法的返回类型相同；
  • 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
  • 父类的成员方法只能被它的子类重写。
  • 声明为final的方法不能被重写。
  • 声明为static的方法不能被重写，但是能够被再次声明。
  • 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
  • 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
  • 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
  • 构造方法不能被重写。
  • 如果不能继承一个方法，则不能重写这个方法。
• super：当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{
   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法

   }
}
//
动物可以移动
狗可以跑和走

重载overload

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

• 规则：
  • 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
  • 被重载的方法可以改变返回类型；
  • 被重载的方法可以改变访问修饰符；
  • 被重载的方法可以声明新的或更广的检查异常；
  • 方法能够在同一个类中或者在一个子类中被重载。
  • 无法以返回值类型作为重载函数的区分标准。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }

    public void test(int a){
        System.out.println("test2");
    }   

    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   

    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   

    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

• 对比
  
  |区别点|重载|重写|
  
  |参数列表|必改|不可改|
  
  |返回类型|可改|不可改|
  
  |异常|可改|可以减少或删除，一定不能抛出新的或者更广的异常|
  
  |访问|可改|一定不能做更严格的限制（可以降低限制）|
  
  方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载是一类中多态性的一种表现。

Java 多态：同一个行为具有多个不同表现形式或形态的能力，是同一个接口，使用不同的实例而执行不同操作

![多态][http://www.runoob.com/wp-content/uploads/2013/12/dt-java.png]

• 优点
  1. 消除类型之间的耦合关系
  2. 可替换性
  3. 可扩充性
  4. 接口性
  5. 灵活性
  6. 简化性
• 多态存在的三个必要条件
  1. 继承
  2. 重写
  3. 父类引用指向子类对象

public class Test {
    public static void main(String[] args) {
      show(new Cat());
      show(new Dog());  

      Animal a = new Cat();
      a.eat();
      Cat c = (Cat)a;
      c.work();
  }  

    public static void show(Animal a)  {
      a.eat();
        if (a instanceof Cat)  {
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) {
            Dog c = (Dog)a;
            c.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}  

class Cat extends Animal {
    public void eat() {
        System.out.println("eatting fish");
    }
    public void work() {
        System.out.println("cathing mouse");
    }
}  

class Dog extends Animal {
    public void eat() {
        System.out.println("eatting bone");
    }
    public void work() {
        System.out.println("keep the door");
    }
}

• 虚方法
• 多态的实现
  • 重写
  • 接口
  • 抽象类和抽象方法

Java 抽象类

OOP上，所有对象都是用来类描绘的，反之不一定，若类中无包含足够信息来描绘一个具体对象该类即抽象类

除不能实例化对象之外，其它功能健在，成员变量成员方法和构造方法的访问方式和普通类一样。

因抽象类不能实例化对象，故抽象类必须被集成才能被使用。父类包含了子类集合的常见方法，但父类本身是抽象的故不能使用这些方法。

Java中抽象类表示一种继承关系，一个类只能集成一个抽象类，而一个类可以实现多个接口。

抽象类

/* 文件名 : Employee.java */
public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay()
   {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + this.name
       + " " + this.address);
   }
   public String toString()
   {
      return name + " " + address + " " + number;
   }
   public String getName()
   {
      return name;
   }
   public String getAddress()
   {
      return address;
   }
   public void setAddress(String newAddress)
   {
      address = newAddress;
   }
   public int getNumber()
   {
     return number;
   }
}

• 总结：
  1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
  2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
  3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
  4. 构造方法，类方法（用static修饰的方法）不能声明为抽象方法。
  5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类

Java 封装(Encapsulation):一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

• 优点:
  1. 良好的封装能够减少耦合。
  2. 类内部的结构可以*修改。
  3. 可以对成员变量进行更精确的控制。
  4. 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）

public class Person {
    private String name;//只能本类才能访问，其他类都访问不了
    private int age;
}

1. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}
//实例
public class EncapTest{

   private String name;
   private String idNum;
   private int age;

   public int getAge(){
      return age;
   }

   public String getName(){
      return name;
   }

   public String getIdNum(){
      return idNum;
   }

   public void setAge( int newAge){
      age = newAge;
   }

   public void setName(String newName){
      name = newName;
   }

   public void setIdNum( String newId){
      idNum = newId;
   }
}

通常情况下，这些方法被称为getter和setter方法。任何要访问类中私有成员变量的类都要通过这些getter和setter方法

Java 接口(Interface):一个抽象类型，是抽象方法的集合，接口通常以interface来声明

一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

• 接口与类相似点：
  • 一个接口可以有多个方法。
  • 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
  • 接口的字节码文件保存在 .class 结尾的文件中。
  • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
• 接口与类的区别：
  • 接口不能用于实例化对象。
  • 接口没有构造方法。
  • 接口中所有的方法必须是抽象方法。
  • 接口不能包含成员变量，除了 static 和 final 变量。
  • 接口不是被类继承了，而是要被类实现。
  • 接口支持多重继承。
• 接口特性
  • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
  • 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。
  • 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
• 抽象类和接口的区别
  1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
  2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口的声明

[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}
//实例
/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包

public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

• 接口有以下特性：
  • 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
  • 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键子。
  • 接口中的方法都是公有的。

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

实现一个接口的语法，可以使用这个公式：

...implements 接口名称[, 其他接口, 其他接口..., ...] ...

接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

Java package:为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间

• 包的作用
  1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
  2. 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，
     
     当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
  3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
• Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

package pkg1[．pkg2[．pkg3…]];

package net.java.util
public class Something{
   ...
}

• 一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。
  • java.lang-打包基础的类
  • java.io-包含输入输出功能的函数

创建包

/* 文件名: Animal.java */
//在 animals 包中加入一个接口（interface）：
package animals;

interface Animal {
   public void eat();
   public void travel();
}

import关键字

import package1[.package2…].(classname|*);
package payroll;

public class Boss
{
   public void payEmployee(Employee e)
   {
      e.mailCheck();
   }
}

package的目录树

---

Java 高级

Java 数据结构

• Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：
  • 枚举（Enumeration）
  • 位集合（BitSet）：位集合类实现了一组可以单独设置和清除的位或标志
  • 向量（Vector）：和传统数组非常相似，但是Vector的大小能根据需要动态的变化。
  • 栈（Stack）：栈（Stack）实现了一个后进先出（LIFO）的数据结构
  • 字典（Dictionary）：是一个抽象类，它定义了键映射到值的数据结构
  • 哈希表（Hashtable）：提供了一种在用户定义键结构的基础上来组织数据的手段。
  • 属性（Properties）：表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
    
    以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collection)

Java 集合框架

• 集合框架被设计成要满足以下几个目标。
  • 该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。
  • 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
  • 对一个集合的扩展和适应必须是简单的。
• 集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
  • 接口：是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言，接口通常形成一个层次。
  • 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。
  • 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
  • 除了集合，该框架也定义了几个Map接口和类。Map里存储的是键/值对。尽管Map不是collections，但是它们完全整合在集合中。

Java 泛型

va 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

Java 序列化

Java 网络编程

Java 多线程编程

Java Applet基础

Java 文档注释

Java 实例

Java 8 新特性

Java MySQL连接