一个简单的java程序
JAVA命名
基本数据类型
- Java常量
运算符
逻辑结构
数组
方法/函数
类与对象
修饰符
- 控制访问修饰符
- 非访问修饰符
Package，Import
一些系统类
- String 一个系统定义好的类
- 数类、字符类、StringBuffer类，输入输出类，日期时间类，都是JAVA里比较重要和基本的内容，但不学了，暂时用不上
异常处理
面向对象

名词不重要，能看懂就行
一个JAVA程序的组成部分可以包括：

JAVA程序也就是我们写的代码，我们写的代码保存为.java格式，如果进行了编译，就会变成.class文件，系统运行的是.class文件。

注意：为了不出现乱七八糟的问题，一般把所有相关的路径，也就是那一串文件夹还有文件名，全部用英文，不要出现中文。

一个简单的java程序

java是一个面向对象的语言，就是所有的东西都在类里面！

public class TestJava {
    public static void main(String[] args) {        // Java操作的一个简单范例，输出和乘方
        int num = 10;                // 定义整型变量
        num = 30;                // 修改变量内容
        System.out.println("num的内容是：" + num);    // 输出内容
        System.out.println("num * num = " + num * num);// 输出乘方
    }
}

//后面的内容是注释，不运行，系统看不见上面这就是一个类，类里面的public static void main(String[] args) 会被运行，其他的所有内容都是为了辅助main。
public class文件名称必须与类名称一致，class文件名称可以与类名称不一致，一般还是叫成一致的，文件里就放一个public class，这样方便。

JAVA命名

一般喜欢取一串用来表示用途的字母数字下划线组合，只能是字母开头。

不要背，注意取名的时候避开就行。

基本数据类型

声明就是

类型 变量名=某数值;

Java常量

常量就是一个固定值。它们不需要计算，直接代表相应的值。
常量指不能改变的量。在Java中用final标志，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
字面量可以赋给任何内置类型的变量。例如：

byte a = 68;
char a = 'A'

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
当使用常量的时候，前缀0表明是8进制，而前缀0x代表16进制。例如：

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"
"two\nlines"
"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';
String a = "\u0001";

详情可以参考：https://www.w3cschool.cn/java/java-basic-datatypes.html

运算符

逻辑结构

数组

数组就是可以存放一组数的地方，而且是一组同类型的数。
要使用Java的数组，必须经过两个步骤：（1）声明数组、（2）分配内存给该数组。

方法/函数

就是一段可重复调用的代码段。

重载，就是可以同一个名字，但实际上确是不同的东西。

类与对象

类：类是一个模板，它描述一类对象的行为和状态。
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
对象的创建、使用、属性访问、方法

构造方法

匿名对象

this

对象数组

修饰符

控制访问修饰符

Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持4种不同的访问权限。
默认的，也称为 default，在同一包内可见，不使用任何修饰符。
私有的，以 private 修饰符指定，在同一类内可见。
共有的，以 public 修饰符指定，对所有类可见。
受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来创建类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。

static

加上static以后不需要具体的某个对象，直接用类的名字就可以直接访问了。

静态方法不能使用非静态变量。
final 变量：
final 变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
实例:

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final 方法

类中的 Final 方法可以被子类继承，但是不能被子类修改。
声明 final 方法的主要目的是防止该方法的内容被修改。
如下所示，使用 final 修饰符声明方法。

public class Test{
    public final void changeName(){
       // 方法体
    }
}

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。
实例：

public final class Test {
   // 类体
}

abstract 修饰符

抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
实例：

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();
实例：

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

Package，Import

Java包

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

Import语句

在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入java/io路径下的所有类

import java.io.*;

一个简单的例子

在该例子中，我们创建两个类：Employee和EmployeeTest。
首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为Employee.java。
Employee类有四个成员变量：name、age、designation和salary。该类显式声明了一个构造方法，该方法只有一个参数。

import java.io.*;
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。
下面给出EmployeeTest类，该类实例化2个Employee类的实例，并调用方法设置变量的值。
将下面的代码保存在EmployeeTest.java文件中。

import java.io.*;
public class EmployeeTest{
   public static void main(String args[]){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();
      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

编译这两个文件并且运行EmployeeTest类，可以看到如下结果：

C :> javac Employee.java
C :> vi EmployeeTest.java
C :> javac  EmployeeTest.java
C :> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

一些系统类

String 一个系统定义好的类

String进行比较：

栈(Stack)：存放基本类型的数据和对象的引用。
堆(Heap)：用于存放所有的Java对象，即用new产生的数据。
静态域：存放在类中用static定义的静态成员。
常量池：常量值通常直接存放在代码内部。

数类、字符类、StringBuffer类，输入输出类，日期时间类，都是JAVA里比较重要和基本的内容，但不学了，暂时用不上

https://www.w3cschool.cn/java/java-number.html
https://www.w3cschool.cn/java/java-character.html
https://www.w3cschool.cn/java/java-date-time.html

异常处理

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
try/catch 代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

还有其他的，但了解这些就够了。
在try内如果程序运行出错了可以用catch后面的程序兜底一下，工程中常见。

面向对象

继承

继承是所有 OOP 语言和 Java 语言不可缺少的组成部分。
继承是 Java 面对对象编程技术的一块基石，是面对对象的三大特征之一，也是实现软件复用的重要手段，继承可以理解为一个对象从另一个对象获取属性的过程。
如果类 A 是类 B 的父类，而类 B 是类 C 的父类，我们也称类 C 是 A 的子类，类 C 是从类 A 继承而来的。在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类。
继承中最常使用的两个关键字是 extends 和 implements 。
这两个关键字的使用决定了一个对象和另一个对象是否是 IS-A (是一个)关系。
通过使用这两个关键字，我们能实现一个对象获取另一个对象的属性。
所有 Java 的类均是由 java.lang.Object 类继承而来的，所以 Object 是所有类的祖先类，而除了 Object 外，所有类必须有一个父类。
通过过 extends 关键字可以申明一个类是继承另外一个类而来的，一般形式如下：

// A.java
public class A {
    private int i;
    protected int j;
    public void func() {
    }
}
// B.java
public class B extends A {
    public int z;
    public void fund(){
    }
}

以上的代码片段说明，类 B 由类 A 继承而来的，类 B 是类 A 的子类。而类 A 是 Object 的子类，这里可以不显示地声明。
作为子类，类 B 的实例拥有类 A 所有的成员变量，但对于 private 类型的成员变量类 B 却没有访问权限，这保障了类 A 的封装性。

extends

public class Animal{
}
public class Mammal extends Animal{
}
public class Reptile extends Animal{
}
public class Dog extends Mammal{
}

基于上面的例子，以下说法是正确的：

Animal 类是 Mammal 类的父类。
Animal 类是 Reptile 类的父类。
Mammal 类和 Reptile 类是 Animal 类的子类。
Dog 类既是 Mammal 类的子类又是 Animal 类的子类。

分析以上示例中的 IS-A 关系，如下：

Mammal IS-A Animal
Reptile IS-A Animal
Dog IS-A Mammal

因此 : Dog IS-A Animal
通过使用关键字 extends ，子类可以继承父类的除 private 属性外所有的属性。
我们通过使用 instanceof 操作符，能够确定 Mammal IS-A Animal

public class Dog extends Mammal{
   public static void main(String args[]){
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();
      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

以上实例编译运行结果如下：

true
true
true

implements 接口的继承

Implements 关键字在类继承接口的情况下使用，这种情况不能使用关键字 extends 。

public interface Animal {}
public class Mammal implements Animal{
}
public class Dog extends Mammal{
}

instanceof 关键字

可以使用 instanceof 运算符来检验 Mammal 和 dog 对象是否是 Animal 类的一个实例。

interface Animal{}
class Mammal implements Animal{}
public class Dog extends Mammal{
   public static void main(String args[]){
      Mammal m = new Mammal();
      Dog d = new Dog();
      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

以上实例编译运行结果如下：

true
true
true

Java 只支持单继承，也就是说，一个类不能继承多个类。
下面的做法是不合法的：

public class extends Animal, Mammal{}

Java 只支持单继承（继承基本类和抽象类），但是我们可以用接口来实现（多继承接口来实现），代码结构如下：

public class Apple extends Fruit implements Fruit1, Fruit2{}

一般我们继承基本类和抽象类用 extends 关键字，实现接口类的继承用 implements 关键字。

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(); //
      b.move(); //执行 Dog类的方法
   }
}

以上实例编译运行结果如下：

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

多态

比如我们说”宠物”这个对象，它就有很多不同的表达或实现，比如有小猫、小狗、蜥蜴等等。那么我到宠物店说”请给我一只宠物”，服务员给我小猫、小狗或者蜥蜴都可以，我们就说”宠物”这个对象就具备多态性。

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

d,a,v,o最后都说的是完全相同的一个Deer
去调用方法的时候也会调用那个对象具体的方法，就像上面super的例子。

抽象

抽象类就是不能直接整出这么个对象，只能拿一个其他的类继承了这个抽象类，才能得到一个对象，有抽象类包含的属性和方法。
抽象方法就是方法只声明了，没写具体怎么实现的。如果谁想继承这个类，除非它自己也是个抽象类，否则就必须把他爹的抽象方法具体地实现出来。

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

接口Interface

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。
接口与类相似点：

一个接口可以有多个方法。
接口文件保存在.java结尾的文件中，文件名使用接口名。
接口的字节码文件保存在.class结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了static和final变量。
接口不是被类继承了，而是要被类实现。
接口支持多重继承。

声明

接口的声明语法格式如下：

[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}

Interface关键字用来声明一个接口。下面是接口声明的一个简单例子。

/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包
public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

接口里面也可以是空的，什么也没有。

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
   public void eat(){
      System.out.println("Mammal eats");
   }
   public void travel(){
      System.out.println("Mammal travels");
   } 
   public int noOfLegs(){
      return 0;
   }
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

以上实例编译运行结果如下:

Mammal eats
Mammal travels

接口的继承

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

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。
相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。

接口的多重继承

在Java中，类的多重继承是不合法，但接口可以。
在接口的多重继承中extends关键字只需要使用一次，在其后跟着继承接口。如下所示：

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口，与类不同的是，接口允许多重继承，而 Sports及 Event 可能定义或是继承相同的方法

JAVA基础

一个简单的java程序

JAVA命名

基本数据类型

Java常量

运算符

逻辑结构

数组

方法/函数

类与对象

对象的创建、使用、属性访问、方法

构造方法

匿名对象

this

对象数组

修饰符

控制访问修饰符

非访问修饰符

static

final 方法

final 类

abstract 修饰符

抽象方法

Package，Import

Java包

Import语句

一个简单的例子

一些系统类

String 一个系统定义好的类

数类、字符类、StringBuffer类，输入输出类，日期时间类，都是JAVA里比较重要和基本的内容，但不学了，暂时用不上

异常处理

面向对象

继承

extends

implements 接口的继承

instanceof 关键字

super 关键字的使用

多态

抽象

接口Interface

声明

接口的实现

接口的继承

接口的多重继承