一、java前期准备

1、java介绍

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发，并在 1995 年正式推出。

后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

2005 年 6 月，JavaOne 大会召开，SUN 公司公开 Java SE 6。此时，Java 的各种版本已经更名，以取消其中的数字 “2”：J2EE 更名为 Java EE，J2SE 更名为Java SE，J2ME 更名为 Java ME。

javase是java的标准版，整个java的基础和核心，也是javaee和javame技术的基础，主要用于开发桌面应用程序。
java用的最多的地方是web应用，javaee就是开发web应用的，javaee也可以叫做j2ee。
javame是专门为嵌入式电子产品设计的java语言，javame也可以叫做j2me。

二、Java语言开发环境搭建

1、Java虚拟机——JVM

JVM（Java Virtual Machine）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java最具吸引力的特性之一。我们编写的Java代码，都运行在JVM之上。

跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系统上，这个特性称为Java****语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM运行在操作系统上。

2、JRE和JDK

JRE(Java Runtime Environment)：是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。

JDK(Java Development Kit)：是Java程序开发工具包，包含JRE和开发人员使用的工具。

我们想要运行一个已有的Java程序，那么只需安装JRE即可。

我们想要开发一个全新的Java程序，那么必须安装JDK。

jdk下载地址

http://www.oracle.com/technetwork/java/javase/downloads/index.html

安装jdk8（1.8）

jdk安装教程：

https://blog.csdn.net/shengmer/article/details/78836255

步骤：

下载——》安装——》环境配置

3、编译工具IDEA

IDEA安装使用参考我另外一篇文章

https://blog.csdn.net/busiruoli/article/details/115147166

我们创建的项目，在d:\ideawork目录的demo下

.idea目录和demo.iml和我们开发无关，是IDEA工具自己使用的
out目录是存储编译后的.class文件
src目录是存储我们编写的.java源文件

三、简单语法入门

1、最简单的java源文件

新建记事本文件，后缀改成 .java

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); }
}

文件名必须是HelloWorld，保证文件名和类的名字是一致的，注意大小写。
每个字母和符号必须与示例代码一模一样。

2、编译、运行

cmd下切换到根目录

编译：

javac Java源文件名.后缀名

例如：

javac HelloWorld.java

执行：

java 类名字

例如：

java HelloWorld

cmd会打印结果。
关于main方法

main****方法：称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。

注释comment

单行注释以//开头换行结束

多行注释以/开头以/结束

3、关键字keywords

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用
	null	空

4、标识符

标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。HelloWorld案例中，出现的标识符有类名字HelloWorld。

**命名规则：**硬性要求

标识符可以包含英文字母26个(区分大小写)、0-9数字、$（美元符号）和_（下划线）。
标识符不能以数字开头。
标识符不能是关键字。

**命名规范：**软性建议

类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
方法名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。
变量名规范：全部小写。

5、常量

6、变量

变量定义的格式包括三个要素：数据类型、变量名、数据值。

数据类型变量名=数据值;

long类型：建议数据后加L表示。

flfloat类型：建议数据后加F表示。

变量名称：在同一个大括号范围内，变量的名字不可以相同。

变量赋值：定义的变量，不赋值不能使用。

7、数据类型转换

7.1、自动转换

byte类型内存占有1个字节，在和int类型运算时会提升为int类型，自动补充3个字节，因此计算后的结果还是int类型。
同样道理，当一个int类型变量和一个double变量运算时，int类型将会自动提升为double类型进行运算。
范围小的类型向范围大的类型提升，byte、short、char运算时直接提升为int。

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

7.2、强制转换

转换格式：

数据类型变量名=（数据类型）被转数据值；

注意

浮点转成整数，直接取消小数点，可能造成数据损失精度。

int强制转成short砍掉2个字节，可能造成数据丢失。

8、运算符

基本运算符与c无差别：算数运算符赋值运算符比较运算符

三元运算符****

计算方式：

数据类型 变量名 = 布尔类型表达式？结果1：结果2

布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

9、方法/回掉/重载

修饰符 返回值类型 方法名 （参数列表）｛ 代码... return ;
｝

**直接调用：**直接写方法名调用

**赋值调用：**调用方法，在方法前面定义变量，接收方法返回值

输出语句调用：

在输出语句中调用方法，System.out.println(方法名())。

不能用输出语句调用void类型的方法。因为方法执行后没有结果，也就打印不出任何内容。

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。

参数列表：个数不同，数据类型不同，顺序不同。

重载方法调用：JVM通过方法的参数列表，调用不同的方法。

简单来说就是同样的方法名称传入不同的参数个数或者类型，都是不同函数。我个人一般不使用。

10、流程控制语句

if else判断语句
switch选择语句
for循环语句
while循环语句
do while循环语句
跳出语句break，continue

break

使用场景：终止switch或者循环

在选择结构switch语句中

continue

使用场景：结束本次循环，继续下一次的循环

11、数组

11.1 定义方法

方法一

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

举例：

int[] arr = new int[3];

方法二****

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

举例：

int[] arr = new int[]{1,2,3,4,5};

方式三

数据类型[] 数组名 = {元素1,元素2,元素3...};

举例：

int[] arr = {1,2,3,4,5};

数组定义格式详解：

数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
new：关键字，创建数组使用的关键字。
数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改。

11.2数组的访问

数组名[索引]

举例：

int[] arr = {1,2,3,4,5};
int i = arr[0]; //i=1

11.3常见操作

数组越界异常

数组空指针异常

12、常用类

12.1 使用步骤

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的字典；

导包

使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。格式：

import 包名.类名;

创建对象

数据类型 变量名 = new 数据类型(参数列表);

调用方法

变量名.方法名();

12.2 Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

备注：System.in系统输入指的是通过键盘录入数据。

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner { public static void main(String[] args) { //2. 创建键盘录入数据的对象 Scanner sc = new Scanner(System.in);//3. 接收数据 System.out.println("请录入一个整数："); int i = sc.nextInt(); //4. 输出数据 System.out.println("i:"+i); }
}

12.3 Random类

此类的实例用于生成伪随机数。

//1. 导包
import java.util.Random;
public class Demo01_Random
{ public static void main(String[] args) { //2. 创建键盘录入数据的对象 Random r = new Random(); for(int i = 0; i < 3; i++){ //3. 随机生成一个数据 int number = r.nextInt(10);//4. 输出数据 System.out.println("number:"+ number); }}
}

12.4 ArrayList类

java.util.ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长。

public class Test02StudentArrayList { public static void main(String[] args) { //创建学生数组 ArrayList<String> list = new ArrayList<>(); //创建学生对象 String s1 = "曹操"; String s2 = "刘备"; String s3 = "孙权"; //打印学生ArrayList集合 System.out.println(list); //把学生对象作为元素添加到集合 list.add(s1); list.add(s2); list.add(s3);//打印学生ArrayList集合 System.out.println(list); }
}

12.5 String类

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

字符串不变：字符串的值在创建后不能被更改。
因为String对象是不可变的，所以它们可以被共享。
“abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。

查看类

java.lang.String ：此类不需要导入。

查看构造方法

public String() ：初始化新创建的 String对象，以使其表示空字符序列。
public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
public char charAt (int index) ：返回指定索引处的 char值。
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符
串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
endIndex截取字符串。含beginIndex，不含endIndex。
public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使
用replacement字符串替换。
public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

String s = "aa|bb|cc";
String[] strArray = s.split("|"); // ["aa","bb","cc"]

12.6 static关键字

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

static 数据类型 变量名；

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

12.7 Arrays类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

12.7 Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) ：返回 double 值的绝对值。
public static double ceil(double a) ：返回大于等于参数的最小的整数。
public static double floor(double a) ：返回小于等于参数最大的整数。
public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

13 异常

四、面向对象

1、面向对象

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

public class Test01_Student {
public static void main(String[] args) { //创建对象格式：类名 对象名 = new 类名(); Student s = new Student(); System.out.println("s:"+s); //cn.itcast.Student@100363 //直接输出成员变量值 System.out.println("姓名："+s.name); //null System.out.println("年龄："+s.age); //0 System.out.println("‐‐‐‐‐‐‐‐‐‐"); //给成员变量赋值 s.name = "赵丽颖"; s.age = 18; //再次输出成员变量的值 System.out.println("姓名："+s.name); //赵丽颖 System.out.println("年龄："+s.age); //18 System.out.println("‐‐‐‐‐‐‐‐‐‐"); //调用成员方法 s.study(); // "好好学习，天天向上" s.eat(); // "学习饿了要吃饭"
}

成员变量和局部变量区别

在类中的位置不同重点

成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)

作用范围不一样重点

成员变量：类中
局部变量：方法中

初始化值的不同重点

成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用

在内存中的位置不同了解

成员变量：堆内存
局部变量：栈内存

生命周期不同了解

成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

2、封装

2.1 概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

封装的步骤

1.使用private关键字来修饰成员变量。

2.对需要访问的成员变量，提供对应的一对getXxx方法、setXxx方法。

2.2 关键字private

private****的关键字含义

private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

public class Student {private String name; private int age; public void setName(String n) { name = n; }public String getName() { return name; }public void setAge(int a) { age = a; }public int getAge() { return age; } }}

2.3 this关键字

形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。

方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

2.4封装优化构造方法

无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

public class Student { private String name; private int age; // 无参数构造方法 public Student() {} // 有参数构造方法 public Student(String name,int age) { this.name = name; this.age = age; }
}

2.5标准代码——JavaBean

JavaBean是Java语言编写类的一种标准规范。符合JavaBean的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法。

public class ClassName{ //成员变量 //构造方法 //无参构造方法【必须】 //有参构造方法【建议】 //成员方法 //getXxx() //setXxx()
}

学生类为例，标准代码如下：

public class Student { //成员变量 private String name; private int age; //构造方法 public Student() {} public Student(String name,int age) { this.name = name; this.age = age; }//成员方法 publicvoid setName(String name) { this.name = name; }public String getName() { return name; }publicvoid setAge(int age) { this.age = age; }publicint getAge() { return age; }
}

测试类，代码如下：

public class TestStudent { public static void main(String[] args) { //无参构造使用 Student s= new Student(); s.setName("章子怡"); s.setAge(18); System.out.println(s.getName()+"‐‐‐"+s.getAge());//带参构造使用 Student s2= new Student("郭德纲",18); System.out.println(s2.getName()+"‐‐‐"+s2.getAge()); }
}

3、继承

3.1extends关键字

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

定义：

就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

class 父类 { ...
}
class 子类 extends 父类 { ...
}

3.2implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

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

3.3 super关键字

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似 this 。

super.父类成员变量名

class Animal
{ void eat() { System.out.println("animal : eat"); }
}
class Dog extends Animal
{ void eat() { System.out.println("dog : eat"); } void eatTest() { this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 }
}
public class Test
{ public static void main(String[] args) { Animal a = new Animal(); a.eat(); Dog d = new Dog(); d.eatTest(); }
}

3.4final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

声明类：

final class 类名 {//类体}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

4、重写&重载

4.1 重写(Override)

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(Override)。方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

重写规则

参数列表与被重写方法的参数列表必须完全相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个类，则不能重写该类的方法。

4.2 重载(Overload)

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

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

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

重载规则:

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

5、抽象类：

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

修饰符 abstract 返回值类型 方法名 (参数列表)；
public abstract void run()；
abstract class 类名字 {
}
public abstract class Animal {public abstract void run()；
}

6、接口

定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

接口就是一种公共的规范标准

public interface 接口名称 { // 抽象方法 // 默认方法 // 静态方法 // 私有方法
}

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。

含有私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

7、多态

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态的优点

1. 消除类型之间的耦合关系
1. 可替换性
1. 可扩充性
1. 接口性
1. 灵活性
1. 简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

8、类的比较

instanceof是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

结尾

欢迎评论点赞加关注，我会继续努力的！

JAVA学习笔记（语言入门篇01）相关推荐

Java学习笔记系列-入门篇-计算机基础
Java学习笔记 Java学习笔记是一个持续更新的系列,工作多年,抽个空对自身知识做一个梳理和总结归纳,温故而知新,同时也希望能帮助到更多正在学习Java 的同学们. 本系列目录: 入门篇计算机基础 ...
JavaScript学习笔记之入门篇
JavaScript学习笔记之入门篇 JavaScript引入 1. 页面级 js: 2. 外部js文件: JavaScript变量 1. 变量的作用: 2. 声明变量: 3. 变量赋值: 4. 单一 ...
Java学习笔记之基础篇
Java学习笔记之基础篇目录 Java如何体现平台的无关性? 面向对象(OO)的理解面向对象和面向过程编程的区别面向对象三大特征静态绑定和动态绑定(后期绑定) 延伸:类之间的关系组合(聚合) ...
经典再现，看到就是赚到。尚硅谷雷神 - SpringBoot 2.x 学习笔记 - 基础入门篇
SpringBoot 2.x 时代 – 基础入门篇视频学习地址:https://www.bilibili.com/video/BV1Et411Y7tQ?p=112&spm_id_from=p ...
Swi-Prolog学习笔记（入门篇）
首先介绍一个学习swi-prolog 和amzi-prolog很靠谱的中文网站:http://hyry.dip.jp/tech/book/page/prolog/search_game_maxmin. ...
持续集成学习笔记－入门篇（1）持续集成基本概念
今年7月份中下旬,笔者见过一个号称"资深开发者"的哥们(据说编程有十来年了),笔者问他:"你们平时用的持续集成工具都有哪些?"这哥们回答:"那些都是骗 ...
金融常识学习笔记之入门篇
金融常识学习笔记拉弗曲线住房痛苦指数 CPI 什么是CPI? 如何才能跑赢CPI? 工资上涨能跑赢CPI吗? PPI 什么是PPI? PPI有什么作用? 恩格尔系数什么是恩格尔系数? 恩格尔系数 ...
Java学习笔记【入门】（1）：Java版本介绍
JavaEE.JavaSE和JavaME的区别首先Java是一门编程语言,根据需求不同分为三个版本 1.javaSE Java SE(Java Platform Standard Edition:J ...
UVM学习笔记—快速入门篇
UVM指的是验证方法学,是学习数字验证的入门课程.它是至关重要的,有不少人往IC验证方向发展的,多多少少都会去了解UVM.但UVM并不是简单的翻个书就可以学会的,还是要掌握学习方法或者跟着老师学习的. ...

JAVA学习笔记 （语言入门篇01）