0002-Java基础知识

一、什么是编程语言，什么是java

Java 是Sun 公司在1995年首次发布的一种编程语言和计算平台

编程语言的作用是描述和与机器沟通的语言

计算机平台是在电脑中运行应用程序（软件）的环境，包含硬件环境和软件环境。一般系统平台包含一台电脑的硬件硬件体系结构、操作系统和运行时库

二、注释

//    单行注释   
/*   多行注释    */    
/** 文档注释 javadoc 文档  API  */      

三、编译两种方式

1 javac helloworld.java
2 javac 绝对路径

经过编译后生成一个 .class文件 字节码文件 ,自动调用字节码文件去使用

（字节 ：电脑可以识别的最小单位）

补充-位、字节、字符、编码关系

1、位：数据存储的最小单位。每个二进制数字0或者1就是1个位；

2、字节： 8个位构成一个字节；即：1 byte (字节)= 8 bit(位)；

 1 KB = 1024 B(字节)；

 1 MB = 1024 KB;   (2^10 B)

 1 GB = 1024 MB;  (2^20 B)

 1 TB = 1024 GB;   (2^30 B)

3、字符：

 a、A、中、+、*、の......均表示一个字符；
 一般 utf-8 编码下，一个汉字 字符 占用 3 个 字节；
 一般 gbk 编码下，一个汉字  字符  占用 2 个 字节；

4、字符集：即各种各个字符的集合，也就是说哪些汉字，字母（A、b、c）和符号（空格、引号…）会被收入标准中

5、编码： 规定每个“字符”分别用一个字节还是多个字节存储，用哪些字节来存储，这个规定就叫做“编码”。（其实际是对字符集中字符进行编码，即：每个字符用二进制在计算中表示存储）；

通俗的说：编码就是按照规则对字符进行翻译成对应的二进制数，在计算器中运行存储，用户看的时候（比如浏览器），在用对应的编码解析出来用户能看懂的；

四、小知识

文件后缀名查看-- 我的电脑 --查看–文件扩展名 --显示后缀

面向对象的语言 Java，面向过程的语言c++，汇编语言

tab 制表符

cmd或者win+r进入命令行 ，从c盘进入D盘

五、类

5.1 Java创建一个HelloWorld类

// public class 关键字,  class 类     类名,类名首字母必须大写，类名和文件名要一致
//括号都成对出现  
//main  函数,又称方法  
public class HelloWorld {
		public static void main(String args[]){
    System.out.println("Hello World");
	
}
}

5.2类、对象、属性、方法

1. 类 对象的抽象,创建对象的模板

2. 对象 类的实例 类与对象的关系 :类是创建对象的模板

3. 属性 对象的特征

4. 方法 操作、对象的行为

六、标识符

标识符：凡是可以自己取名的地方都是标识符
合法的标识符 由数字 字母 下划线 $符组成 ,不得用数字开头,避开Java 关键字

//合法的标识符
a123  _123 $123 abc123
//非法的标识符
 1a    .a   /a

一般来说标识符需要遵守驼峰命名法

类名的每一个字母的首字母大写,其余小写 ,比如 HelloWorld PersonInfor StudentInfor

方法首字母小写，起源于字母开头大写，比如 getStudentName setStudentName

七、关键字

7.1访问控制

private 一种访问控制方式：私用模式
protected 一种访问控制方式：保护模式
public 一种访问控制方式：公用模式

7.2类方法变量修饰符

abstract 表明类或者成员方法具有抽象属性
class 类
extends 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
implements 表明一个类实现了给定的接口
interface 接口
native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new 用来创建新实例对象
static 表明具有静态属性
strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
synchronized 表明一段代码需要同步执行
transient 声明不用序列化的成员域
volatile 表明两个或者多个变量必须同步地发生变化
break 提前跳出一个块
continue 回到一个块的开始处
return 从成员方法中返回数据
do 用在do-while循环结构中
while 用在循环结构中
if 条件语句的引导词
else 用在条件语句中，表明当条件不成立时的分支
for 一种循环结构的引导词
instanceof 用来测试一个对象是否是指定类型的实例对象
switch 分支语句结构的引导词
case 用在switch语句之中，表示其中的一个分支
default 默认，例如，用在switch语句中，表明一个默认的分支

7.3错误处理

try 尝试一个可能抛出异常的程序块
catch 用在异常处理中，用来捕捉异常
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常

7.4包相关

import 表明要访问指定的类或包
package 包

7.5基本类型

boolean 基本数据类型之一，布尔类型
byte 基本数据类型之一，字节类型
char 基本数据类型之一，字符类型
double 基本数据类型之一，双精度浮点数类型
float 基本数据类型之一，单精度浮点数类型
int 基本数据类型之一，整数类型
long 基本数据类型之一，长整数类型
short 基本数据类型之一,短整数类型

7.6变量引用

super 表明当前对象的父类型的引用或者父类型的构造方法
this 指向当前实例对象的引用
void 声明当前成员方法没有返回值

7.7保留字

goto 保留关键字，没有具体含义
const 保留关键字，没有具体含义

八、数据类型

数据类型有两种（基本数据类型+引用数据类型）

1 byte (字节)= 8 bit(位)

3byte转化为二进制为：0000 0011 ，切记第一位为符号位，即0代表+，1代表-，剩下的七位是数据位）

8.1基本数据类型（8种）

（1）布尔 boolean 1字节 取值只有两种 true false，取其他的都会报错
（2）字符 char 2字节 2^16-1 字符不能是负数。

gbk编码下，一个字符能存一个中文汉字（2字节）（utf-8下一个汉字是3字节）
（3）整型（4个）

​ byte 1字节 字节 -2^7 ~ 2^7-1 即-128 ~ 127。 末尾加B

​ short 2 字节 短整型 -2^15 ~2^15-1 末尾加S

​ int 4字节 整型 -2^31 ~2^31-1

​ 有符号 -2^31 ~2^31-1 Integer

​ 无符号 0 ~ 2^32-1 int

​ long 8字节 长整型 -2^63 ~ 2^63-1

（4）浮点型（2个）

​ float 单精度 4字节 32位 8位存指数,23位存尾数

​ double 双精度 8字节 64位 11位存指数,52位存尾数

float和double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少次方。

8.2引用数据类型（3种）

有三种，数组，类，接口，值默认为null

8.21.数组

数组：存储在一个连续的内存块中的相同数据类型（引用数据类型）的元素集合。

指定数据类型和固定长度的元素集合。

数组中的每一个数据称之为数组元素，数组中的元素以索引来表示其存放的位置，索引（下标）从0开始。

数组的定义

第一种方式：类型[] 数组名; 如 int[] nums;
第二种方式：类型 数组名[]; 如 int nums[];
大多数Java程序员喜欢使用第一种风格,因为它把数据类型int[],和变量名num分开了.
数组的初始化
Java中数组必先初始化后才能使用.
初始化就是给数组元素分配内存，并为每个元素赋初始值。
初始化数组的两种方式：

• 静态初始化:
  语法格式: 类型[] 数组名 = new 数组类型[]{元素1,元素2,元素3,…元素n}; int[] arr =new arr[]{1,2,3}
  简化语法：类型[] 数组名 = {元素1,元素2,元素3…元素n}; int[] arr ={1,2,3}
• 动态初始化:
  如果我们事先不知道数组里存储哪些数据，只知道需要存储数据的个数，此时可以使用动态初始化方式。
  动态初始化：初始化时由我们指定数组的长度，系统自动为数组元素分配初始值。
  格式：类型[] 数组名 = new 数组类型[数组长度]; int[] arr = new int[3]
  注意:无论，以哪种方式初始化数组，一旦初始化完成，数组的长度就固定了，不能改变，除非重新初始化。也就是说数组是定长的。

8.22.类

Object ：Object是一个很重要的类，Object是类层次结构的根类，每个类都使用Object作为超类，所有对象（包括数组）都实现这个类的方法。用Object可以定义所有的类 如：
Object object= new Integer(1); 来定义一个Interger类
Integer i=(Integer) object; 在来把这个Object强制转换成Interger类

String ：String类代表字符串，Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例来实现。检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本、在该副本中、所有的字符都被转换为大写或小写形式。
Date ：Date表示特定的瞬间，精确到毫秒。Date的类一般现在都被Calendar 和GregorianCalendar所有代替
Void ：Void 类是一个不可实例化的占位符类，它保持一个对代表 Java 关键字 void 的 Class 对象的引用。
同时也有对应的Class如：Integer Long Boolean Byte Character Double Float Short

8.23.接口

可以是我们创建的，主要是讲解几个java库中的接口interface
List：列表 ，此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引 （在列表中的位置）访问元素，并搜索列表中的元素。List 接口提供了两种搜索指定对象的方法。从性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜索。 List 接口提供了两种在列表的任意位置高效插入和移除多个元素的方法。

add() : 在列表的插入指定元素。
remove()：移除列表中指定位置的元素。
get(int index)：返回列表中指定位置的元素。

Map<K,V>：
K - 此映射所维护的键的类型
V - 映射值的类型 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

put(K key,V value)：将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的映射关系，则用指定值替换旧值（当且仅当，返回 true 时，才能说映射 m 包含键 k 的映射关系）。

remove(Object key)如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。更确切地讲，如果此 映射包含从满足(key= =null ? k==null :key.equals(k))的键 k 到值 v 的映射关系，则移除该映射关系。（该映射最多只能包含一个这样的映射关系.） get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
这里我们主要是用String List Map Object 是最常用Number ArrayList Arrays等

8.3类型转换

8.31隐式转换（自动转换）

（1）boolean类型与其他基本类型不能进行类型的转换（既不能进行自动类型的提升，也不能强制类型转换）， 否则将编译出错。

（2）整型、实型(常量)、字符型数据可以混合运算。不同类型的数据先转化为同类型再进行运算

（3）自动转换按从低级到高级顺序:

​ char→int

​ Byte→short→int→long—›float→double

（4）隐式转换规律

小类型自动转化为大类型，隐式转换

整数类型可以自动转化为浮点类型，可能会产生舍入误差。精准度和准确度是有差距的，float精准度的准确性流失

常量只要不超出范围,可以隐式转换

8.32显示类型转换（强制转换）

（1）大类型转小类型必须强制转换，最后转为int

（2）强制类型转换可能导致溢出或损失精度

（3）强制转换类型，在要强制转换类型的前面加上括号，然后再括号里面加上你要转换的类型。

  格式： (type)value ， type是要强制类型转换后的数据类型

（4）浮点数转换整数是通过舍弃小数得到的，而不是四舍五入

//隐式转换  jvm 将常量 int 10 转换为 byte 10  系统默认所有常量为int
byte b=10 
//强制转换
int i=1
byte b=(byte)i ;

//浮点类型
long l =9999999999999999999   会报错  因为int装不下这个数
long l =9999999999999999999L     
//不加L  伴随着隐式转换，  加L jvm把值当作long
     
float f=(float)1.0
float f=1.0F
    
double d=1.0    
float f2=(float)d
    
   
char 字符
char c='a'
char c1='aa'   不是字符,是字符串
    
char a='我'   中文也是字符
GBK 国家通用标准字符库 
utf-8 国际通用标准编码

    
// 所有的都有负数,除了char  
 char     0-2^16-1 
    
 byte b=1
 char c=b     错误 
        
long l=1000
float f =l
    
    
//只要不超出范围，double可以强转float
 重要的是要注意，将float转换为double实际上比将double转换为float更危险，即使Java允许前者隐式没有警告而是对后者发出警告。将浮点数转换为double会导致系统选择其范围以浮点范围的中心为中心的double。这几乎总会产生一个值，其实际不确定性远远大于双精度数的典型值。

8.4为什么Java里有基本数据类型和引用数据类型？

基本类型在栈里，引用类型在堆里

栈空间小且连续，往往会被放在缓存。引用类型的高速缓存率高且要多一次解引用。

对象还要再多储存一个对象头，对基本数据类型来说空间浪费率太高

九、二进制

9.1二进制

二进制是一套计数方法，每个位置上的数有 2 种可能（0 和1）；二进制是计算机的执行语言

1个字节,由八位的二进制组成 0000 0000

十进制里最大数9 0-9

0000 0000 0

0000 0001 1

0000 0010 2

…

1000 0000 128

9.2二进制与十进制换算

一个字节能描述的最大整数 和最小整数 ,用八位去描述 最大 2^7-1=127 最小 -2^7

电脑要分出一位给符号位 ，正负号

正数10

0000 1010 源码

负数 -10

0000 1010 源码

1111 0101 先算反码 （按位取反）

0000 0001 再算补码 ,反码基础上+1 满2进1,进位

1111 0110 补码 -10

1000 0000 128

0111 1111 反码

0000 0001 反码+1

1000 0000 补码 -128

二进制表示负数 ,事实上找与正数相加为0的

十、变量

声明变量 ：数据类型+变量名(标识符)

一个变量要使用,一定要经过 声明 和初始化 ,初始化就是系统赋值或者个人赋值

//声明  int型变量，名字叫 i  
int i;
//10为常量,i为变量   对变量i进行初始化. 第一次赋值叫初始化,之后的叫赋值
i=10;
// 声明变量j 并初始化为100              declare 声明
int j=100;
//java中 所有的整数常量 默认是int
//jshell 
/reset  重置常态    

int a,b,c    如果不赋值,系统将其初始化为0
int a=1,b=2,c=3
    
boolean a='true'
boolean a='false' 
boolean b=null   错误
只有这两种,其余全错.
      
byte b=127
byte只有一个字节,所以最大为127,超出则错误.
    

量 ：数据类型+变量名(标识符)

一个变量要使用,一定要经过 声明 和初始化 ,初始化就是系统赋值或者个人赋值

//声明  int型变量，名字叫 i  
int i;
//10为常量,i为变量   对变量i进行初始化. 第一次赋值叫初始化,之后的叫赋值
i=10;
// 声明变量j 并初始化为100              declare 声明
int j=100;
//java中 所有的整数常量 默认是int
//jshell 
/reset  重置常态    

int a,b,c    如果不赋值,系统将其初始化为0
int a=1,b=2,c=3
    
boolean a='true'
boolean a='false' 
boolean b=null   错误
只有这两种,其余全错.
      
byte b=127
byte只有一个字节,所以最大为127,超出则错误.