一篇文章能够看懂基础源代码之JAVA篇

java程序开发使用的工具类包：JDK（java development kit）
java程序运行需要使用的虚拟机：JVM，只需要安装JRE （java runtime environment）
java源码文件：后缀是.java
编译后的字节码文件：后缀是class
运行class文件：源码中必须有 public static void main(String[] args)方法，这样才能启动运行。

创新互联是一家专注于成都网站制作、网站建设与策划设计,白河网站建设哪家好?创新互联做网站,专注于网站建设10余年,网设计领域的专业建站公司;建站业务涵盖:白河等地区。白河做网站价格咨询:028-86922220

把多个文件打包成一个模块来运行：jar文件，jar文件由多个class组成，可以有main入口运行，也可以没有。

需要运行的jar包必须指定一个MainClass，里面必须有main方法

概念：

1. 代码结束符：每行代码必须以分号;作为结束符.
2. 访问修饰符：控制类或变量，或方法的访问权限，public是外部能够访问，private只有内部和同一个包的类能访问，protected只有内部和有继承关系的能访问
3. 实例对象：每个类在内存中实际运行的内容

4. 类：一般情况下，一个源文件就是一个类，用类来划分代码结构，代码内容包含在类里面，以大括号包裹
   public class MyClass {}

5. package：包，和文件夹的功能类似，用来对类进行分组，在类文件的首行，例如
   package com.mypackagename.mysubpack;

6. 导入类：一个类需要引用另外一个类的内容时需要导入，例如：
   import com.mypack.MyClassB;
   导入静态类：
   import static com.myPack.MyClassB.MyStaticClass;
   导入静态类后可以直接使用静态类里的静态方法，例如可以
   myStaticMethod();
   如果没有导入静态类则需要，MyStaticClass.myStaticMethod();

7. 构造方法（或称构造函数），用来实例化类的方法，分为带参和不带参，默认不带参的为空构造方法，可以省略，特殊情况下不能省略。名称和类名一致。
   public MyClass(){}

8. 方法：在类里面的一个执行代码块，可以给外部或者内部调用
   访问修饰符 返回类型 方法名(参数){}
   public MyReturnType myMethod(String myParam){}

9. 变量：

   10. 全局变量：在类里面声明的变量，所有方法都能使用
       public class MyClass {
       private String myGlobalVar;
       }

   11. 局部变量：在方法或者代码块里面声明的变量，只有方法和内部代码块能使用，不能使用访问修饰符：
       public String myMethod() {
       String myLocalVar = "";
       {

        Integer myLocalVar2 = 0;

       }
       }

   12. 参数：声明在方法里的变量，只能在方法体内使用
       public String myMethod(String myParam){}
       可以在参数类型上使用...来表示多个参数，使用时作为数组来使用
       public String myMethod(String... myParams){}
       myParams[0] myParams[1]

10. 运算符：算术运算符，逻辑运算符

11. 注解：用来描述代码的一些内容信息，主要分为单行和多行注解，单行使用//即可，也可以使用/内容/，多行使用/* 内容/，每一行前都加一个*

/**

• 这里是注释

*/

下面以代码示例进行描述：

package com.kavy.test; //定义包名
import com.kavy.test.sub.SubLevelClass; //导入其他包的类
import java.util.ArrayList;
import java.util.List;

import static com.kavy.test.sub.SubLevelClass.MyStaticClass;//静态类导入需要添加static
public class MyMain { //声明一个MyMain的类
//声明全局变量,在类内部使用
private String myGlobalVar;
//声明全局静态变量,可以给外部直接使用
public static String myGlobalStaticVar;
//声明不可修改的全局常量,final声明的变量一旦赋值就不能更改，否则编译时报错
private final String MY_FINAL_VAR = "FINAL";

//类的运行入口,执行这个class文件时会找到这个方法进行调用
public static void main(String[] args) {
    new MyMain(); //实例化类,在内存中创建一个MyMain对象
}

//无参构造函数
public MyMain() {
    String myLocalVar = "";//声明局部变量，只能在这个构造函数方法体内部使用
    {
        String myLocalVarTwo = "";//局部变量,只能在方法体{}内使用
    }
    new SameLevelClass();//同一个包下的类可以不需要使用import导入可以直接使用
    new SubLevelClass();//不同包的类需要先导入才能使用
    MyStaticClass.myStaticMethod();
    SubLevelClass.MyStaticClass.myStaticMethod();
    //算术运算符： + - * / % 加,减,乘,除,求余
    //逻辑运算符：用作判断 && 与， ||或  !非
    //三目运算：myCondition ? a : b  如果条件为真则执行a，为假则执行b
    //自增运算： ++ -- ，变量在左边时，先返回变量，然后再自增
    int a = 0;
    int b = a++;//等同于 int b = a; a = a + 1;
    int c = ++a; //等同于  a = a + 1; int c = a;
    //逻辑判断
    if (true) {
    } else if (false) {
    } else {
    }
    //循环：fori dowhile, while do
    for(int i = 0; i < 10; i++){} //(初始条件,判断条件;增加值，用分号分隔
    String[] str = new String[10];//声明一个数组，长度为10
    for(String o: str){}  //使用forin循环
    do {
    } while (a < 10); //do while循环,无论while条件如何都会执行一次do内容
    while (a < 10) {};//while循环，只有while条件符合才会执行里面的内容
    List myList = new ArrayList<>();
    myList.forEach(item -> {}); //使用JDK1.8以后提供的stream和lambda表达式来简化书写
    //分支语句：
    switch (a) {
        case 1:   //a =1执行一些内容,执行完末尾必须加上break，否则会
            break;
        case 2: //a =2执行一些内容
            break;
        default:   //上面的值都没有时
            break;
    }

    //异常：分为运行时异常和检查时异常,finally为无论异常怎样都会执行
    try {
    } catch (Exception e) {
    } finally {
    }
}
//有参构造函数
public MyMain(String myParam) {}

//有参，有返回值的,内部和外部都可以调用的实例方法
public String myMethod(String... myParam){
    return "";
}
//方法重载：同名，同返回类型；参数类型，个数不一样
public String myMethod(String paramA, Integer paramB) {
    return "";
}

//内部类：在一个类内部再声明一个类
class MySub extends MyMain {  //继承：使用extends继承父类，拥有父类的除了private修饰的所有内容
    //方法覆盖：子类覆盖父类的方法，名称，返回类型，参数类型个数都一样，只有方法体内部的内容不一样
    public String myMethod(String paramA, Integer paramB) {
        return "son";
    }
}
//使用abstract声明抽象类，一般类的方法都需要有方法体内容，抽象类的抽象方法不需要有方法体内容，方法体内容交给继承的子类实现
//含有抽象方法的类都是抽象类
abstract class MyAbstract{
    abstract void myAbstractMethod();
}
//声明一个接口,接口里只有方法和变量，没有实体内容,方法体的内容交给实现这个接口的类来做，和抽象类不同的就是抽象类可以有实体内容
interface MyInterface {
    void myMethod();
}

}