自学JAVA
目录
目录
Java语言概述
Java语言概述:Java简史
Java语言概述：Java语言的诞生
Java语言概述：主要特性
Java语言运行机制及运行过程
Java语言的环境搭建
JDK、JRE、JVM关系
下载并安装JDK
配置环境变量path
开发体验————HelloWorld
注释（Comment）
文档注释:
第一个JAVA程序总结
良好的编程风格
关键字与保留字
标识符(Identifier)
Java基本语法
变量
变量的了解
基本数据类型转换
字符串类型：String
运算符
算术运算符
三元运算符
数据输入
Scanner使用的基本步骤
类和对象
类的定义
对象的使用
成员变量和局部变量的区别
封装
private关键字
Java语言概述
Java是SUN(Stanford University Network，斯坦福大学网络公司）1995年推出的一 门高级编程语言。 是一种面向Internet的编程语言。Java一开始富有吸引力是因为Java程序可以 在Web浏览器中运行。这些Java程序被称为Java小程序（applet）。applet使 用现代的图形用户界面与Web用户进行交互。 applet内嵌在HTML代码中, 随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言
Java语言概述:Java简史
1991年Green项目，开发语言最初命名为Oak （橡树)
1994年，开发组意识到Oak 非常适合于互联网
1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作
1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最
1998年，发布JDK 1.2，同年发布企业平台J2EE
1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
2009年，Oracle公司收购SUN，交易价格74亿美元
2011年，发布JDK 7.0 2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本
2017年，发布JDK 9.0，最大限度实现模块化
2018年3月，发布JDK 10.0，版本号也称为18.3
2018年9月，发布JDK 11.0，版本号也称为18.9
Java语言概述：Java语言的诞生
java之父James Gosling团队在开发”Green"项目时，发现c缺少垃圾回收系统，还有可移植的安全性、分布程序设计和多线程功能。最后，他们想要一种易于移植到各种设备上的平台！ Java确实是从C语言和C++语言继承了许多成份，甚至可以将Java看 成是类c语言发展和衍生的产物。比如Java语言的变量声明，操作符 形式，参数传递，流程控制等方面和C语言、C++语言完全相同。但同 时，Java是一个纯粹的面向对象的程序设计语言，它继承了C++语言 面向对象技术的核心。Java舍弃了C语言中容易引起错误的指针（以 引用取代）、运算符重载（operator overloading）、多重继承 (以接口取代)等特性，增加了垃圾回收器功能用于回收不再被引用 的对象所占据的内存空间。JDK1.5又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱
Java语言概述：主要特性
Java语言是安全的。Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的 名字空间以防替代本地的同名类、字节代码检查,
Java语言是体系结构中立的。Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个 Java平台的任何系统中运行。
Java语言是解释型的。如前所述，Java程序在Java平台上被编译为字节码格式， 然后可以在实现这个Java平台的任何系统的解释器中运行。
Java是性能略高的。与那些解释型的高级脚本语言相比，Java的性能还是较优的。
Java语言是原生支持多线程的。在Java语言中，线程是一种特殊的对象，它必须 由Thread类或其子（孙）类来创建。
Java语言属于半编译半解释型语言。
最开始Java是解释型语言，因为Java通过javac命令编译生成的是.class的二进制字节，后来Java为了提高执行效率，引入了JIT，也就是即时编译，Java程序最初是通过解释器（Interpreter）进行解释执行的，
当虚拟机发现某个方法或代码块的运行特别频繁时，就会把这些代码认定为“热点代码”。为了提高热点代码的执行效率，
在运行时，虚拟机将会把这些代码编译成与本地平台相关的机器码，并进行各种层次的优化，完成这个任务的编译器称为
即时编译器（Just In Time Compiler）所以说JIT才是Java的编译型的体现
因此Java才属于半编译半解释型语言。
Java语言运行机制及运行过程
Java语言的特点
特点一：面向对象
√两个基本概念：类、对象
√三大特性：封装、继承、多态
特点二：健壮性
√吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制
特点三：跨平台性
√跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once, Run Anywhere”
√原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
Java两种核心机制：
JAVA虚拟机（Java Virtual Machine）
垃圾收集机制（Garbage Collection)
Java语言的环境搭建
JDK(Java Development Kit Java开发工具包)
JDK是提供给Java开发/员使用的，其中包含了java的开发工具，也包括了 JRE。所以安装了JDK，就不用在单独安装JRE了。
其中的开发工具：编译工具(javac.exe)打包工具(jar.exe)等
JRE(Java Runtime Environment Java运行环境)
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等, 如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
简而言之，使用JDK的开发工具完成的java程序，交给JRE去运行。
JDK、JRE、JVM关系
JDK=JRE+开发工具集(例如Javac编译工具等)
JRE=JVM+Java SE标准类库
下载并安装JDK
官方网址：www.oracle.com
java.sun.com
下载完成后安装只需要点击下一步即可。
建议：安装路径不要有中文或者空格等特殊符号
当提示安装JRE时，虽然在JDK安装时已经安装过了，但为了后续使用Eclipse等开发工具不报错，建议根据提示安装JRE。
配置环境变量path
在dos命令行中敲入javac，出现错误提示：
错误原因：当前执行的程序在当前目录下如果不存在，windows系统会在系统中已有的一个名为path的环境变量指定的目录中查找。如果仍未找到，会出现以上的错误提示。所以进到JDK安装路径\bin目录下，执行javac，会看到javac参数提示信息。
为了方便，我们可以将java工具所在路径定义到path环境变量中，让系统帮我们去找运行执行的程序。
配置方法：
此电脑——属性——高级系统设置——环境变量
编辑path环境变量(建议系统变量)——编辑——新建——加入java工具所在目录
打开DOS命令行，任意目录下敲入javac，如果出现javac的参数信息，配置成功。
开发体验————HelloWorld
步骤：1、将java代码编写到扩展名为.java的文件下。
2、通过javac命令对该java文件进行编译
3、通过java命令对生成的class文件进行运行。
class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld!");
}
}
注释（Comment）
JAVA中的注释类型：
单行注释
多行注释
class HelloWorld{ //单行注释：main方法是程序的入口！ /* 多行注释：main方法是程序的入口！ main的格式是固定的。 */ public static void main(String[] args){ System.out.println("HelloWorld!"); } }文档注释（java特有）
作用：
提高代码的可读性，调试程序的重要方法
文档注释:
格式：/**
@author 指定java程序的作者
@version 指定源文件的版本
*/
注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
操作方式：
javadoc -d mydoc(自己设置文档名字) -auther -version HelloWorld(java文件的名字).java
第一个JAVA程序总结
1、java程序编写-编译-运行的过程
编写： 我们将编写的java代码保存在以“.java”结尾的源文件中
编译：使用javac.exe命令编译我们的java源文件。
格式：javac 源文件名.java
运行：使用java.exe命令解释运行我们的字节码文件。
格式：java 类名
2、在一个java源文件中可以声明多个class。但是，最多只能有一个类声明为public的。
而且要求声明为public的类的类名必须与源文件名相同。
3、程序的入口是main()方法。格式是固定的。
4、输出语句：
System.out.println();先输出数据，然后换行
System.out.print();只输出数据
5、每一行执行语句都以";"结束。
6、编译的过程：编译以后，会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。
public class Helloone{//在一个java源文件中可以声明多个class。但是，最多只能有一个类声明为public的。而且要求声明为public的类的类名必须与源文件名相同。
public static void main(String[] args){/*程序的入口是main()方法。格式是固定的。?
但也可以有改变的地方，比如：public static void main(String args[]) args是arguments(参数)的缩写，可以随意改变
public static void main(String[] a) public static void main(String a[])*/
System.out.println("Hello Word!");//先输出数据，然后换行
System.out.println("Hello Word!");//先输出数据，然后换行
System.out.print("Hello Java!");//只输出数据
System.out.print("Hello Java");//只输出数据
}
}
class Add{
}
class Son{
}
良好的编程风格
正确的注释和注释风格
使用文档注释来注释整个类和整个方法
如果注释方法中的某一个步骤，使用单行或多行注释
正确的缩进和空白
使用一次tab操作，实现缩进
运算符两边习惯性各加一个空格。比如：1 + 2 * 3
块的风格
行尾风格
public class Test{ public static void main(String[] args){ System.out.println("Hello Java"); } }次行风格
public class Test { public static void main(String[] args) { System.out.println("Hello Java"); } }
关键字与保留字
关键字(keyword)的定义和特点：
#定义：被java语言赋予了特殊含义，用作专门用途的字符串。
#特点：关键字中所有字母都为小写。
| class | interface | enum | byte | short |
| int | long | float | double | char |
| boolean | void |
| if | else | switch | case | default |
| while | do | for | break | continue |
| return |
| private | protect | public |
| abstract | final | static | synchronized |
| extends | inplements |
| new | this | super | instanceof |
| try | catch | finally | throw | throws |
| package | import |
| native | strictfp | transient | volatile | assert |
| true | false | null |
保留字： 现有java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要 避免使用这些保留字。
goto、const
标识符(Identifier)
Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
定义合法标识符规则：
→由26个英文字母大小写，0~9，_或$组成
→数字不可以开头
→不可以使用关键字和保留字，但能包含关键字和保留字
→Java中严格区分大小写，长度无限制
→标识符不能包含空格
Java基本语法
变量
变量的了解
变量的概念:内存中的一个存储区域；
该区域中的数据可以在同一类型范围内不断变化；
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。
变量的作用：用于在内存中保存数据。
使用变量注意:
→Java中每个变量必须先声明，后使用
→变量的作用域：其定义所在的一个{}内
→同一个作用域不能定义重名的变量
/*
变量的使用
*/
public class JavaUse {
public static void main(String[] args) {
int a = 12;//变量的定义
System.out.println(a);//变量的使用
//System.out.println(b);//编译错误，为定义变量b。必须先声明后使用
int b;
//System.out.println(b);//编译错误，未初始化变量b
b = 10;
System.out.println(b);//变量的使用
}
//System.out.println(a);//编译错误，未在其作用区域内
}
变量的分类：
基本数据类型：数值型：
整数类型：byte,short,int,long
浮点型：float,double
字符型：char
布尔型：boolean
引用数据类型：类(class)
接口(interface)
数组([ ])
变量的分类按声明位置的不同
在方法体外，类体内声明的变量称为成员变量
在方法体内部声明的变量称为局部变量
float:单精度，尾数可以精确到7位有效数字
double:双精度，精度是float的两倍
char:用来表示通常意义上的字符(2字节)
Java中所有字符都使用Unicode编码，所有一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
→字符型变量的三种表现形式:
1.字符常量是用单引号' ' 括起来的单个字符。例如：char c = 'a';char c1 = '中';
char c3 = '2';
2.Java还允许使用转义字符'\'来将其后的字符转变为特殊字符常量
例如：char c = '\n';//'\n'表示换行符
3.直接使用Unicode值来表示字符型常量：’\uXXXX‘。其中，XXXX代表一个十六进制整
数
char类型是可以进行运算的，因为它都有对应的Unicode码。
//变量类型练习测试
class Variab{
public static void main(String[] args) {
//1.整型：byte(1字节=8bit)/short(2字节)/int (4字节)/long(8字节)
// byte范围：-128~127
byte b1 = 127;
byte b2 = -128;
//byte b3=128;//编译不通过，超出byte范围
System.out.println(b1);
System.out.println(b2);
short s1 = 12;
int i = 123;
//声明long型变量，必须以“l”或“L”结尾
long l = 91388001l;
System.out.println(s1);
System.out.println(i);
System.out.println(l);
//2.浮点型：float(4字节)/double(8字节)
float f = 12.3f;//声明float类型变量时，必须以“f”或“F”结尾
System.out.println(f);
double d =12.3;
System.out.println(d);
//3.字符型：char(1字符=2字节)
//定义char型变量时，通常使用一对'',内部只能写一个字符
char c = '中';
char c1 ='国';
char c2 = '牛';
System.out.print(c);
System.out.print(c1);
System.out.println(c2);
//char还可以定义转义字符
char c3 = '\n';//换行符
char c4 = '\t';//制表符
System.out.print("中国" + c3);
System.out.println("世界第一");
System.out.print("中国" + c4);
System.out.println("世界第一");
//4.布尔型:boolean
//只能取两个值之一：true false
boolean My = true;
if(My) {
System.out.println("中国就是世界第一！");
}
else {
System.out.println("中国不是世界第一。");
}
}
}
基本数据类型转换
自动类型转换:容量小的数据类型自动转换为容量大的数据类型。
数据类型按容量大小排序为：
1.有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
（这里的容量指的是，表示数的范围的大和小）
2.byte,short,char之间不会进行相互转换，他们三者再进行计算时首先转换成int类型。
3.boolean数据类型不能与其他数据类型运算。
4.当把任何基本数据类型的值和字符串(String)进行连接运算时，基本数据类型的值将自动转换为字符串类型。
//这里不讨论boolean类型
public class Variable {
public static void main(String[] args) {
byte b = 2;
int i = 3;
//byte b1 = b + i;//出错！byte的容量小于int,将byte型常量和int型常量做运算，应该用int接收
int i1 = b + i;
System.out.println(i1);
long l = b + i;
System.out.println(l);//也可以用long型接收，除了byte,short,char类型不能接收，其他都可以接收
}
}
强制类型转换：自动类型提升运算的逆运算。
需要使用强转符：()
强制类型转换可能导致精度损失
public class VariableTest {
public static void main(String[] args) {
double d = 12.9;
int i = (int)d;//截断操作，精度损失
System.out.println(d);
System.out.println(i);
long l = 1223232L;
double d1 = (double)l;//没有精度损失
System.out.println(l);
System.out.println(d1);
}
}
字符串类型：String
1.*String不是基本数据类型，属于引用数据类型。
2.使用方式与基本数据类型一致，例如：String str = "abcd";
3.一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str + "ujei";
int a = 19;
str = str + n;
4. 声明String类型变量时，使用一对" "
5.String可以和8种基本数据类型做运算，而且运算只能是连接运算：+
运算的结果仍然是String类型。
public class StringTest {
public static void main(String[] args) {
String s = "中国，你好！";
System.out.println(s);
String s1 = "每个中国人都有身份证";
System.out.println(s1);
long i = 610525200010051234L;
String s2 = "我的身份证号是：";
String s3 = s2 + i;//连接运算，运算结果还是String类型
System.out.println(s3);
boolean b = true;
String s4 = s + b;
System.out.println(s4);//String类型也可以和布尔类型进行连接运算
}
}
运算符
运算符是一种特殊的符号，用来表示数值的运算、赋值和比较等。
运算符有：算术运算符、赋值运算符、比较运算符(关系运算符)、逻辑运算符、位运算符
三元运算符
算术运算符
算术运算符：+(加法运算或正值) -(减法运算或负值) *(乘法运算) /(除法运算 取整) %(除法运算 取余) ++(自增运算 ) --(自减运算)
在数学中，算术运算符有一套完整的运算规则。在Java中，算术运算符也同样存在这种规则。
算术运算符优先级：先乘除后加减，先括号里再括号外，优先级相同，按照自左向右的顺序进行运算。
public class Test01 {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(-a);//对a进行取负操作 单目运算符
System.out.println(+a);//取正操作
System.out.println(a+b);//加法运算
System.out.println(a-b);//减法运算
System.out.println(a*b);//乘法运算
System.out.println(a/b);//除法运算 结果为商，忽略余数
System.out.println(a%b);//除法运算 结果为余数，忽略商
System.out.println(++b);//自增运算 先自增再运算
System.out.println(a++);//自增运算 先运算再自增
System.out.println(a);//这里输出的上一行a自增后的结果
int c = 3;
int d = 4;
System.out.println(--c);//自减运算 先自减再运算
System.out.println(d--);//自减运算 先运算再自减
System.out.println(d);//这里输出的是上一行d自减后的结果
//************************************************
//%取余运算 结果的符号与被模数相同
int a1 = 12;
int b1 = -5;
System.out.println(a1%b1);
int a2 = -12;
int b2 = 5;
System.out.println(a2%b2);
int a3 = 12;
int b3 = 5;
System.out.println(a3%b3);
int a4 = -12;
int b4 = -5;
System.out.println(a4%b4);
}
}
三元运算符
格式：
▷(条件表达式)？表达式1：表达式2；
如果条件表达式为true，运算后的结果是表达式1；否则结果为表达式2；
▷表达式1和表达式2为同种类型。
数据输入
Scanner使用的基本步骤
①导包
import java.util.Scanner
导包的动作必须出现在类定义的上边
②创建对象
Scanner sc = new Scanner(System.in);
sc是变量名，可以改变。其他的都不允许改变。
③接收数据
int i = sc.nextInt();
i是变量名，可以改变。其他的都不允许变。
//导包
import java.util.Scanner;
public class ScannerTest{
public static void main(String[] args){
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
int x = sc.nextInt();
//输出数据
System.out.println("x:" + x);
}
}
这里需要输入数据！
输入数据后：
类和对象
类：类是对现实生活中一类具有共同属性和行为的事物的抽象。
对象：是能够看到到摸得着的真实存在的实体。
类和对象的关系：类是对象的抽象，对象是类的实体
类的定义
类的重要性：类是java程序的基本组成单位。
类： 类是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为。
类的组成：属性和行为
● 属性：在类中通过成员变量来体现
● 行为：在类中通过成员方法来体现
/*定义类的步骤：
1、定义类
2、编写类的成员变量
3、编写类的成员方法
*/
//定义类
public class 类名{
//成员变量
变量的数据类型 变量;
//成员方法
方法 1;
方法 2;
}对象的使用
创建对象：
格式： 类名 对象名 = new 类名();
使用对象：
1、成员变量
格式：对象名.变量名
package class01;
public class Student {
//成员变量
String name;
int age;
//成员方法
public void study() {
System.out.println("好好学习，天天向上！");
}
public void doHomework() {
System.out.println("键盘敲烂，月薪过万！");
}
}
package class01;
public class StudentTest {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//使用对象
System.out.println(s.name + "," + s.age);
//给成员变量赋值
s.name = "小米";
s.age = 20;
System.out.println(s.name + "," + s.age);
//调用成员方法
s.study();
s.doHomework();
}
}
成员变量和局部变量的区别
| 区别 | 成员变量 | 局部变量 |
| 类中位置不同 | 类中方法外 | 方法内或方法声明上 |
| 内存中位置不同 | 堆内存 | 栈内存 |
| 生命周期不同 | 随着对象的存在而存在，随着对象的消失而消失 | 随着方法的调用而存在，随着方法的调用完毕而消失 |
| 初始化值不同 | 有默认的初始化值 | 没有默认的初始化值，必须先定义，赋值，才能使用 |
封装
private关键字
▶是一个权限修饰符
▶可以修饰成员(成员变量和成员方法)
▶作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问
private修饰的成员变量，如果需要被其他类使用，则
▶提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
▶提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
this关键字
▶this用于修饰的变量用于指代成员变量
●方法的形参如果与成员变量同名，不带this修饰符的变量指的是形参，而不是成员变量
●方法的形参没有与成员变量同名，不带this修饰符的变量指的是成员变量
▶什么时候使用this?解决局部变量隐藏成员变量
▶this：代表所在类的对象引用
方法被哪个对象调用，this就代表哪个对象
package test01;
public class Student
{
private String name;
private int age;
public void getName(String name)
{
this.name=name;// this.name指代的是成员变量
System.out.println(name);
}
public String setName()
{
return name;
}
public void getAge(int age)
{
this.age=age;
System.out.println(age);
}
public int setAge()
{
return age;
}
}
package test01;
public class StudentDemo
{
public static void main(String[] args)
{
Student s=new Student();
s.getAge(20);
s.getName("iowhwoeh");
// System.out.print();
}
}
构造方法
构造方法是一种特殊的方法，作用是创建对象
格式：
public class 类名{
修饰符 类名(参数){
}
}
功能：主要是完成对象数据的初始化
构造方法的创建：
◉如果没有定义构造方法，系统将会给出一个默认的无参构造方法
构造方法的重载：
◉如果自定义了带参构造方法，还要使用无参构造方法，就必须在写一个无参构造方法
继承
继承是java三大特性之一。可以使子类拥有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。
父类：也称为基类，超类
子类：也称为派生类
格式：public class 子类名 extends 父类名{}
继承中子类的特点：
◉子类可以有父类的内容
◉子类还可以有自己特有的内容
继承的好处：提高了代码的复用性和维护性
继承的弊端：继承让类与类之间产生了关系，类的耦合性增强，当父类发生变化时子类实现也不得不发生变化，削弱了子类的独立性。
继承中变量的访问特点
在子类方法中访问一个变量
查找顺序：子类局部范围，子类成员范围，父类成员范围。如果都没有就会报错
super