Java 重要特点
-
Java 语言是面向对象的(oop)
-
Java 语言是健壮的。Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证
-
Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台]
-
Java 语言是解释型的[了解]
**解释性语言：**javascript,PHP, java 编译性语言: c / c++
区别是：解释性语言，编译后的代码，不能直接被机器执行,需要解释器来执行, 编译性语言, 编译后的代码, 可以直接被机器执行, c /c++
Java 的开发工具
工具选择
如何选择开发工具
我们先选择用文本编辑器本 sublime，到大家对 java 有一定了解后，我们再使用 IDEA 和 Eclipse 开发工具。
这是为什么呢
更深刻的理解 java 技术,培养代码感。【面试时，往往程序员手写代码】有利于公司面试。
Java 运行机制及运行过程
Java 语言的特点：跨平台性
Java 核心机制-Java 虚拟机 [JVM java virtual machine]
基本介绍
- JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在
JDK 中. - 对于不同的平台，有不同的虚拟机。
- Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行” [说明]
示意图
什么是JDK，JRE
JDK 基本介绍
- JDK 的全称(Java Development Kit Java 开发工具包) JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]
- JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。
JRE 基本介绍
- JRE(Java Runtime Environment Java 运行环境) JRE = JVM + Java 的核心类库[类]
- 包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。
2.7.3 JDK、JRE 和JVM 的包含关系 - JDK = JRE + 开发工具集（例如 Javac,java 编译工具等)
- JRE = JVM + Java SE 标准类库（java 核心类库）
- 如果只想运行开发好的 .class 文件 只需要 JRE
下载、安装 JDK
官方网址:
https://www.oracle.com/java/technologies/javase-downloads.html
细节说明
安装路径不要有中文或者特殊符号如空格等。比如d:\program\hspjdk8当提示安装JRE时,可以选择不安装,也可以安装.
配置环境变量 path
为什么要配置path
√看一个现象
在dos命令行[快捷方式 win+r]中敲入javac，出现错误提示。
C: \Users \Administrator>javac
javac'不是内部或外部命令，也不是可运行的程序或批处理文件。
C: \Users\Administrator> java
java’不是内部或外部命令，也不是可运行的程序或批处理文件。
√原因分析
错误原因:当前执行的程序在当前目录下如果不存在，win10系统会在系统中已有的一个名为path的环境变量指定的目录中查找。如果仍未找到，会出现以上的错误提示。所以进入到 jdk安装路径\bin目录下,执行javac，会看到javac参数提示信息。
配置环境变量path 的步骤
1.我的电脑–属性–高级系统设置–环境变量
2.增加JAVA_HOME 环境变量,指向jdk的安装目录d:\program(hspjdk83.编辑path环境变量,增加%JAVA HOME%\bin
4.打开DOS命令行，任意目录下敲入javac/java。如果出现javac的参数信息，配置成功。
常用的dos 命令
- 查看当前目录是有什么内容 dir
dir
dir d:\abc2\test200
- 切换到其他盘下：盘符号 cd : change directory
案例演示：切换到 c 盘 cd /D c: - 切换到当前盘的其他目录下 (使用相对路径和绝对路径演示), …\表示上一级目录案例演示： cd d:\abc2\test200 cd …\abc2\test200
- 切换到上一级：案例演示： cd …
- 切换到根目录：cd
案例演示：cd \ - 查看指定的目录下所有的子级目录 tree
- 清屏 cls [苍老师]
- 退出 DOS exit
- 说明: 因为小伙伴后面使用 DOS 非常少，所以对下面的几个指令，老韩给大家演示下, 大家了解即可 (md[创建目录],rd[删除目录],copy[拷贝文件],del[删除文件],echo[输入内容到文件],type,move[剪切]) => Linux,
变量
为什么需要变量
一个程序就是一个世界
变量是程序的基本组成单位
不论是使用哪种高级程序语言编写程序,变量都是其程序的基本组成单位，比如:
//变量有三个基本要素(类型+名称+值)
class Test{
public static void main(String [args){
int a=1;//定义了一个变量,类型int整型,名称a,值1
int b=3;//定义了一个变量,类型int整型,名称b,值3
b=89;//把89值赋给b变量
System.out.println(a);//输出a变量的值
System.out.println(b);//输出b变量的值
}
}
简单的原理示意图
变(变化)量(值)的介绍
概念
变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。
变量使用的基本步骤
- 声明变量
int a; - 赋值
a = 60; //应该这么说: 把 60 赋给 a
使用 System.out.println(a);
//也可以一步到位[int a = 60; 通常我们是一步完成]
变量快速入门
变量使用入门案例:
看演示并对代码进行说明， 演示记录 人的信息的代码
public class Var02 {
//编写一个 main 方法
public static void main(String[] args) {
//记录人的信息 int age = 30;
double score = 88.9;
char gender = '男';
String name = "king";
//输出信息, 快捷键 System.out.println("人的信息如下:");
System.out.println(name);
System.out.println(age);
System.out.println(score);
System.out.println(gender);
}
}
变量使用注意事项
public class VarDetail {
//编写一个 main 方法
public static void main(String[] args) {
//变量必须先声明，后使用, 即有顺序
int a = 50;//int System.out.println(a);//50
//该区域的数据/值可以在同一类型范围内不断变化
//a = "jack"; //× a = 88; //对
System.out.println(a);//88
//变量在同一个作用域内不能重名
//int a = 77;//错误
}
}
class Dog {
public static void main(String[] args) {
int a = 666;//对
}
}
程序中 +号的使用
1.当左右两边都是数值型时,则做加法运算
2.当左右两边有一方为字符串,则做拼接运算
3.运算顺序，是从左到右
数据类型
每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。
上图说明
- java 数据类型分为两大类 基本数据类型， 引用类型
- 基本数据类型有 8 中 数值型 [byte , short , int , long , float ,double] char , boolean
- 引用类型 [类，接口， 数组]
整数类型
基本介绍
Java 的整数类型就是用于存放整数值的，比如 12 , 30, 3456 等等
案例演示：
byte n1 = 10; short n2 = 10;
int n3 = 10;//4 个字节
long n4 = 10; //8 个字节
整型的类型
浮点类型
基本介绍
Java 的浮点类型可以表示一个小数，比如 123.4 ，7.8 ，0.12 等等
浮点型的分类
说明
- 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
- 尾数部分可能丢失，造成精度损失(小数都是近似值)。
浮点型使用细节 FloatDetail.java
字符类型(char)
基本介绍
字符类型可以表示单个字符,字符类型是 char，char 是两个字节(可以存放汉字)，多个字符我们用字符串 String(我们后面详细讲解 String)
案例演示 Char01.java
#代码
char c1 = 'a';
char c2 = '\t';
char c3 = 'yan';
char c4 = 97;
字符类型使用细节
注：
1．字符型存储到计算机中，需要将字符对应的码值（整数)）找出来，比如’a’
存储: ‘a’==>码值97 ==>二进制(110 0001) ==>存储
读取: 二进制(110 0001) =>97 ===> ‘a’=>显示
2.字符和码值的对应关系是通过字符编码表决定的(是规定好)
字符编码表[sublime测试]：
ASCII (ASCIl编码表一个字节表示，一个128个字符,实际上一个字节可以表示256个字符,只用128个)
Unicode (Unicode编码表固定大小的编码使用两个字节来表示字符，字母和汉字统一都是占用两个字节,这样浪费空间)
utf-8(编码表,大小可变的编码字母使用1个字节，汉字使用3个字节)
gbk(可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)
gb2312(可以表示汉字,gb2312<gbk)
big5码(繁体中文,台湾,香港)
ASCII 码介绍(了解)
Unicode 编码介绍(了解)
UTF-8 编码介绍(了解)
布尔类型：boolean
运算符
定义
运算符指明对操作数的运算方式。
分类
算术运算符
+ - + - * / % ++ -- +
注意事项
1、/ 左右两端的类型需要一致；
2、%最后的符号和被模数相同；
3、前++；先+1，后运算 后++；先运算，后+1；
4、+：当String字符串与其他数据类型只能做连接运算；并且结果为String类型；
比较运算符（关系运算符）
+= -= *= /= %=
比较运算符1
比较运算符2
注意事项
1、比较运算符的两端都是boolean类型，也就是说要么是true，要么是false；
2、比较运算符的"==“与”="的作用是不同的，使用的时候需要小心。
赋值运算符
+= -= *= /= %=
-
基本的赋值运算符：=
-
扩展的赋值运算符：+=,-=,*=,/=,%= +=: a+=20;相当于a = (a的数据类型)(a + 20);
逻辑运算符（符号的两端都是boolean类型）
& | ^ ! && ||
注意事项
1、& 与 &&以及|与||的区别：
&：左边无论真假，右边都会进行运算；
&&：如果左边为假，则右边不进行运算；
| 与 || 的区别同上；在使用的时候建议使用&&和||；
2、（^）与或（|）的不同之处是：当左右都为true时，结果为false。
逻辑运算符
位运算符（两端都是数值型的数据）
位运算符1
位运算符2
三元运算符（三目运算符）
三元运算符
注意事项
1、表达式1与表达式2的类型必须一致；
2、使用三元运算符的地方一定可以使用if…else代替，反之不一定成立；
运算符的优先级
运算符的优先级
优先级按照从高到低的顺序书写，也就是优先级为1的优先级最高，优先级14的优先级最低。使用优先级为 1 的小括号可以改变其他运算符的优先级。
进制(程序员的基本功)
进制介绍
对于整数，有四种表示方式：
**二进制：**0,1 ，满 2 进 1.以 0b 或 0B 开头。
十进制：0-9 ，满 10 进 1。
**八进制：**0-7 ，满 8 进 1. 以数字 0 开头表示。
十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。
举例说明 BinaryTest.java
//演示四种进制
//
public class BinaryTest {
//编写一个 main 方法
public static void main(String[] args) {
//n1 二进制
int n1 = 0b1010;
//n2 10 进制
int n2 = 1010;
//n3 8 进制
int n3 = 01010;
//n4 16 进制
int n4 = 0X10101;
System.out.println("n1=" + n1);
System.out.println("n2=" + n2);
System.out.println("n3=" + n3);
System.out.println("n4=" + n4);
System.out.println(0x23A);
}
}
进制的图示
进制的转换(基本功)
进制转换的介绍
第一组：
- 二进制转十进制
- 八进制转十进制
- 十六进制转十进制
第二组：
- 十进制转二进制
- 十进制转八进制
- 十进制转十六进制
第三组
- 二进制转八进制
- 二进制转十六进制
第四组
- 八进制转二进制
- 十六进制转二进制
二进制转换成十进制示例
八进制转换成十进制示例
十六进制转换成十进制示例
**规则：**从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。案例：请将 0x23A 转成十进制的数
0x23A = 10 * 16^0 + 3 * 16 ^ 1 + 2 * 16^2 = 10 + 48 + 512 = 570
十进制转换成二进制
**规则：**将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：将 34 转成二进制 = 0B00100010
十进制转换成八进制
规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
案例：将 131 转成八进制 => 0203
十进制转换成十六进制
**规则：**将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：将 237 转成十六进制 => 0xED
二进制转换成八进制
**规则：**从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
案例：请
将 ob11010101 转成八进制
ob11(3)010(2)101(5) => 0325
二进制转换成十六进制
**规则：**从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
案例：将 ob11010101 转成十六进制
ob1101(D)0101(5) = 0xD5
八进制转换成二进制
规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。
案例：将 0237 转成二进制
02(010)3(011)7(111) = 0b10011111
十六进制转换成二进制
**规则：**将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
案例：将 0x23B 转成二进制
0x2(0010)3(0011)B(1011) = 0b001000111011
二进制在运算中的说明
1.二进制是逢2进位的进位制，0、1是基本算符。
2.现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数字符号，
非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary) 数用O和1两个数字及其组合来表示任何数。进位规则是"逢2进1"，数字1在不同的位上代表不同的值，按从右至左的次序，这个值以二倍递增。
原码、反码、补码(重点 难点)
对于有符号的而言:
1．二进制的最高位是符号位:0表示正数,1表示负数(口诀: 0->0,1->-)
2.正数的原码,反码,补码都一样(三码合一)
3．负数的反码=它的原码符号位不变，其它位取反(0->1,1->0)4、
负数的补码=它的反码+1，负数的反码=负数的补码-1.
0的反码，补码都是0
6. java没有无符号数,换言之，java中的数都是有符号的
7. 在计算机运算的时候，都是以补码的方式来运算的.(因为补码将正数和负数统一起来了)
8. 当我们看运算结果的时候，要看他的原码(重点)
运算符举例：
java 中有 7 个位运算(&、|、^、~、>>、<<和 >>>)
2&3
计算机以补码进行运算：
2：00000000 00000000 00000000 00000010 （补码）
3：00000000 00000000 00000000 00000011（补码）
&：00000000 00000000 00000000 00000010 （补码）
计算机以原码显示：00000000 00000000 00000000 00000010(原码）
结果：2
~-2：
-2原码：10000000 00000000 00000000 00000010
-2反码：11111111 11111111 11111111 11111101
-2补码：11111111 11111111 11111111 11111110
取反： 00000000 00000000 00000000 00000001（运算后的补码）
原码： 00000000 00000000 00000000 00000001（原码）
结果：1
~2：
2原码：00000000 00000000 00000000 00000010
2补码：00000000 00000000 00000000 00000010
取反： 11111111 11111111 11111111 11111101（运算后的补码）表示负数
反码=补码-1： 11111111 11111111 11111111 11111100
原码： 10000000 00000000 00000000 00000011（符号位不变）
结果：-3
还有 3 个位运算符 >>、<< 和 >>> , 运算规则:
- 算术右移
>>：低位溢出,符号位不变,并用符号位补溢出的高位 - 算术左移
<<: 符号位不变,低位补 0 >>>逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0- 特别说明：没有
<<<符号
eg：
1) int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
2) int c=1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4
类与对象
看一个养猫猫问题
张老太养了两只猫猫
:一只名字叫小白,今年 3 岁,白色。
还有一只叫小花,今年 100 岁,花色。
请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。
public class Object01 {
//编写一个 main 方法
public static void main(String[] args) {
/*
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。
还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
则显示 张老太没有这只猫猫。
*/
//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
//第 1 只猫信息
String cat1Name = "小白";
int cat1Age = 3;
String cat1Color = "白色";
// 第 2 只猫信息
String cat2Name = "小花";
int cat2Age = 100;
String cat2Color = "花色";
//数组 ===>
//(1)数据类型体现不出来
//(2)只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确
//(3)不能体现猫的行为
//第 1 只猫信息
String[] cat1 = {"小白", "3", "白色"};
String[] cat2 = {"小花", "100", "花色"};
}
}
使用现有技术解决
- 单独的定义变量解决
- 使用数组解决
现有技术解决的缺点分析
不利于数据的管理
效率低===》
引出新知识点 类与对象
java 设计者 引入 类与对象(OOP) ，加粗样式根本原因就是现有的技术，不能完美的解决新的新的需求.
概述类与对象
一个程序就是一个世界，有很多事物(对象[属性, 行为])
类与对象的关系示意图
类与对象的关系示意图
入门-面向对象的方式解决养猫问题
代码
public class Object01 {
//编写一个 main 方法
public static void main(String[] args) {
/*
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。
还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
则显示 张老太没有这只猫猫。
*/
//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
//第 1 只猫信息
// String cat1Name = "小白";
// int cat1Age = 3;
// String cat1Color = "白色";
// 第 2 只猫信息
// String cat2Name = "小花";
// int cat2Age = 100;
// String cat2Color = "花色";
//数组 ===>
//(1)数据类型体现不出来
//(2)只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确
//(3)不能体现猫的行为
//第 1 只猫信息
// String[] cat1 = {"小白", "3", "白色"};
// String[] cat2 = {"小花", "100", "花色"};
//使用 OOP 面向对象解决
//实例化一只猫[创建一只猫对象]
//1. new Cat() 创建一只猫(猫对象)
//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1
//3. cat1 就是一个对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 10;
//创建了第二只猫，并赋给 cat2
//cat2 也是一个对象(猫对象)
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
cat2.weight = 20;
//怎么访问对象的属性呢
System.out.println("第 1 只猫信息" + cat1.name + " " + cat1.age + " " + cat1.color + " "+cat1.weight);
System.out.println("第 2 只猫信息" + cat2.name
+ " " + cat2.age + " " + cat2.color + " "+cat2.weight);
}
}
//使用面向对象的方式来解决养猫问题
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
//属性/成员变量
String name; //名字
int age; //年龄
String color; //颜色
//double weight; //体重
//行为
}
类和对象的区别和联系
通过上面的例子可以看出:
- 类是抽象的，概念的，代表一类事物,比如人类,猫类…, 即它是数据类型.
- 对象是具体的，实际的，代表一个具体事物, 即 是实例.
- 类是对象的模板，对象是类的一个个体，对应一个实例
对象在内存中存在形式(重要)
属性/成员变量/字段
基本介绍
- 从概念或叫法上看： 成员变量 = 属性 = field(字段) （即 成员变量是用来表示属性的)
例：
public class Object02 {
//编写一个 main 方法
public static void main(String[] args) {
}
}
class Car {
String name;//属性, 成员变量, 字段 field
double price;
String color;
String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)
}
- 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类 的 int age 就是属性
注意事项和细节说明 - 属性的定义语法同变量，示例：访问修饰符
属性类型 属性名;
访问修饰符： 控制属性的访问范围
有四种访问修饰符 public, proctected, 默认, private - 属性的定义类型可以为任意类型，包含基本类型或引用类型
- 属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000， boolean false，String null
例：
public class PropertiesDetail {
//编写一个 main 方法
public static void main(String[] args) {
//创建 Person 对象
//p1 是对象名(对象引用)
//new Person() 创建的对象空间(包括数据) 才是真正的对象
Person p1 = new Person();
//对象的属性默认值，遵守数组规则:
//int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
System.out.println("\n 当前这个人的信息"); System.out.println("age=" + p1.age + " name="
+ p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
}
}
class Person {
//四个属性
int age;
String name;
double sal;
boolean isPass;
}
如何创建对象
- 先声明再创建
Cat cat1 ; //声明对象cat1
cat1 = new Cat(); //创建 - 直接创建
Cat cat = new Cat();
如何访问属性
基本语法
对象名.属性名;
cat.name ;
cat.age;
cat.color;
类和对象的内存分配机制(重要)
看一个思考题
我们定义一个人类(Person)(包括 名字,年龄)。
类和对象的内存分配机制
Java 内存的结构分析
- 栈： 一般存放基本数据类型(局部变量)
- 堆： 存放对象(Cat cat , 数组等)
- 方法区：常量池(常量，比如字符串)， 类加载信息
- 示意图 [Cat (name, age, price)]
Java 创建对象的流程简单分析
Person p = new Person();
p.name = “jack”;
p.age = 10
- 先加载 Person 类信息(属性和方法信息, 只会加载一次)
- 在堆中分配空间, 进行默认初始化(看规则)
- 把地址赋给 p , p 就指向对象
- 进行指定初始化， 比如 p.name =”jack” p.age = 10
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
