java学到能看懂代码_一篇文章能够看懂基础源代码之JAVA篇

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

发布时间：2020-05-19 11:20:32

来源：51CTO

阅读：305

作者：栖木之地

java程序开发使用的工具类包：JDK(java development kit)

java程序运行需要使用的虚拟机：JVM，只需要安装JRE (java runtime environment)

java源码文件：后缀是.java

编译后的字节码文件：后缀是class

运行class文件：源码中必须有 public static void main(String[] args)方法，这样才能启动运行。

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

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

概念：

代码结束符：每行代码必须以分号;作为结束符.

访问修饰符：控制类或变量，或方法的访问权限，public是外部能够访问，private只有内部和同一个包的类能访问，protected只有内部和有继承关系的能访问

实例对象：每个类在内存中实际运行的内容

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

public class MyClass {}

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

package com.mypackagename.mysubpack;

导入类：一个类需要引用另外一个类的内容时需要导入，例如：

import com.mypack.MyClassB;

导入静态类：

import static com.myPack.MyClassB.MyStaticClass;

导入静态类后可以直接使用静态类里的静态方法，例如可以

myStaticMethod();

如果没有导入静态类则需要，MyStaticClass.myStaticMethod();

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

public MyClass(){}

方法：在类里面的一个执行代码块，可以给外部或者内部调用

访问修饰符 返回类型 方法名(参数){}

public MyReturnType myMethod(String myParam){}

变量：

全局变量：在类里面声明的变量，所有方法都能使用

public class MyClass {

private String myGlobalVar;

}

局部变量：在方法或者代码块里面声明的变量，只有方法和内部代码块能使用，不能使用访问修饰符：

public String myMethod() {

String myLocalVar = "";

{

Integer myLocalVar2 = 0;

}

}

参数：声明在方法里的变量，只能在方法体内使用

public String myMethod(String myParam){}

可以在参数类型上使用...来表示多个参数，使用时作为数组来使用

public String myMethod(String... myParams){}

myParams[0] myParams[1]

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

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

/**

这里是注释

*/

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

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

}

}