java语言基础

大家好啦 这是小潘写的第二篇博客啦。 接着上一篇java前言的。 还是继续说的是java的基础 知识，小白也可以看懂哒

上次说到Java语言的架构

java语言有三种架构 分别是JAVAEE, JAVASE,JAVAME

分别是企业版------帮助开发可移植，健壮的服务端的应用程序，是在javaSE的基础之上的，提供Web服务，组件模型，管理和通信API

标准版-----------开发部署桌面，服务器，嵌入式的Java应用程序

小型版-------开发移动设备和嵌入式的设备

J2EE(Java 2 Platform Enterprise Edition)企业版
可帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java 应用程序。Java EE 是在Java SE 的基础上构建的，它提供Web 服务、组件模型、管理和通信API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和Web 2.0 应用程序。
J2SE（Java 2 Platform Standard Edition）标准版
它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的Java 应用程序，能为Java EE提供开发基础。比如Java版的扫雷。
J2ME(Java 2 Platform Micro Edition)小型版
用来开发移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）。现在使用的越少用了，Android会逐渐的取代J2ME的市场份额。
Java5.0版本后，更名为 JAVAEE JAVASE JAVAME

下面说一下Java的跨平台？

跨平台本身是：同一个软件在不同的操作系统上面可以运行 也就是Java里面所说的一次编译，到处运行

跨平台的原理是因为我们有jvm java的虚拟机，相当于来说是给我们搭建了一个平台， 由jvm负责java程序在该系统中的运行，

因为有了jvm, 同一个程序在三个不同的操作系统上都是可以执行的，实现了java程序的跨平台性.(相当与说

自己给自己准备了一个java平台)

需要理解的一句话就是：java语言是跨平台的，但是jvm不是跨平台的

下面介绍JDK,JVM,JRE

JDK:(java development kit) JDK=JRE+JAVA开发工具包

JVM:(java virtual machine ) Java虚拟机 JVM= JRE+java核心类库

JRE: (java runtime environment ) java运行环境

扩展知识：JRE的bin目录里的就是JVM，lib中则是JVM工作所需要的类库

下面介绍配置环境变量

1. （右键）此电脑–>高级系统设置–>环境变量
2. 编辑path环境变量，在变量值开始处加上java工具所在目录，后面用 “ ; ”和其他值分隔开即可。
3. 打开DOS命令行，任意目录下敲入javac。
4. 如果出现javac的参数信息，配置成功。 配置成功的是环境变量

为什么要配置？下次使用的话直接就会到环境变量里面去找 任何环境下都可以直接运行。

导致对path变量值的误操作, 可以通过以下技巧完成。

新创建一个环境变量 JAVA_HOME 记录住jdk的目录。在path中通过%%动态的获取JAVA_HOME的值即可。

JAVA_HOME=D:\Java\jdk1.8 你的jdk的目录

path=%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin 中间的;是不能省略的奥

%path%：动态获取path环境变量的值。

%JAVA_HOME%：动态获取名称为JAVA_HOME环境变量的值。

​

Java程序的编写分为三个步骤：①.编写源文件【.java】、②.编译成字节码文件【.class】、③.`执行.class文件

在你使用记事本的时候，一定要注意扩展名改为了 .java 想要运行我们的记事本写的java文件的话，打开我们的命令行， 进行盘符的切换，进入到你的bin目录下，使用javac 执行的文件名.java

没有错误的话，这时就已经生成好了字节码文件， 使用java 文件名 就可以了

下面介绍Scanner 类

Scanner 类，可以使我们的用户输入，实现计算机与用户的交互

使用的步骤

（1）导包： import java.util.Scanner;

（2）给出控制台阻塞： Scanner scanner=new Scanner(System.in)；

（3）接收用户的输入： int String double 等等

int a=scanner.nextInt();

可以读取的数据类型有： int ,long ,byte,float,short,double

接收字符串的两种方式：String s=scanner.next(); String s=scanner.nextLine();

总结了几个小的知识点：

（1）Java语言拼写上严格区分大小写；

（2）一个java源文件当中是可以有多个java类的，但是只能有一个类被定义为public 类

（3）源文件的名必须和public 类的名字同名

（4）一个源文件有几个类，就会有几个字节码文件，每一个字节码文件和对应 的类名一样

加油加油奥，下面还有一些知识，当我们静下心来学习的时候，就已经算小半成功了

（4）main方法是程序执行的入口 被我们的虚拟机调用

写法是：public static void main(String[]args){

}

main方法是静态的，没有返回值类型的，它被我们的虚拟机进行调用， 有没有返回值类型没有意义

参数列表里面是一个字符串的数组

关于注释的

注释：是用来解释说明程序的文字 ，提高了我们代码的阅读性

注释有：单行注释： // 单行注释和多行注释我们的编译器是不理睬的

​ 多行注释 /* */ 单行注释和多行注释只是方便阅读

​ 文档注释 /** */

在/** */之间的所有字符会被编译器忽略,java特有的(用于生成文档);

注意：多行和文档注释都不能嵌套使用

对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。对于文档注释，是Java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

注释是一个程序员必须要具有的良好编程习惯。初学者编写程序可以养成习惯：先写注释再写代码。将自己的思想通过注释先整理出来，再用代码去体现。

说一下我们java当中的关键字

定义数据类型：class、interface、byte、short、int、long、float、double、char、boolean、void

数据类型的值： true、false、null

流程控制：if、else、switch、case、default、while、do、forbreak、continue、return

权限修饰符：private、protected、public、

类、函数、变量修饰符：abstract、final、static、 synchronized

类之间关系：extends、implements

异常处理：try、catch、finally、throw、throws

包 package、import

其他修饰 native（执行本地c）、strictfp（类、接口或方法上 约束表达式）、 transient（对象上不会被序列化） 、volatile（弱同步）、assert（断言）

其他修饰的可以不管，看看就好了 。

关于标识符：

可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法名，变量名等。

标识符组成：

1. 标识符标识符是有字母，数字，下划线，组成的，不能由数字开头，再不能使用其他的组成
2. 标识符大小写敏感的；
3. `标识符 不得使用java中的关键字和保留字；
4. 别用Java API里面的类名作为自己的类名 那样的话虚拟机就会混；

注意：在起名字的时，只要标识符不是关键字就可以了，但为了提高阅读性，经常用有意义的英文单词作为标识符。

标识符书写规范： 这个是软要求，建议是这样

• 包名：多单词组成时所有字母都小写。xxxyyyzzz

• 类名接口名：多单词组成时，所有单词的首字母大写。XxxYyyZzz 简明知意

• 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。xxxYyyZzz 使用的是驼峰命名法

• 常量名：常量就是不可变的，final修饰的 所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

  二进制，八进制 ，十进制，十六进制的转换

  ​

     //2进制转10进制
  

  public static void main(String args[]) {
  Scanner input = new Scanner(System.in);
  System.out.print("输入一个二进制数 ");
  int binaryNumber = input.nextInt();//二进制数
  int decimal = 0;// 十进制数字
  int p = 0;// 位数
  while (true) {
  if (binaryNumber == 0) {
  break;
  } else {
  //把输入的二进制数 取它的每一位
  int temp = binaryNumber % 10;
  //从前面开始取余 刚好符合2进制数字转十进制数字
  decimal += temp * Math.pow(2, p);
  binaryNumber = binaryNumber / 10;
  p++;
  }
  }
  System.out.println(“十进制数为:”+decimal);
  }
  ​

  //10转2
  
  public static void main(String[] args) {
  Scanner input = new Scanner(System.in);
  System.out.print("输入一个十进制数 ");
  int n = input.nextInt();
  String str = "";
  while (n != 0) {
  //10进制转为二进制的话   除2取余数最后倒着写
  //字符串的拼接就仿写了倒着写的过程
  	str = n % 2 + str;
      n = n / 2;
  }
  System.out.println(str);
  

  java中的变量

  变量：表示的是内存当中的一块存储区域 不断地来存放同一类型地常量数据

  定义的格式： 数据类型 变量名=初始化值; （格式固定的）

  =号是赋值符号 ==判断的是否相等

  int a=10; 声明了一个int类型变量名为a，它的初始值是10

  int b; 光声明了但是没有进行初始化。

  变量的命名表示的是; 在内存中的一个存储区域，这时必须给这个区域起个名字 ，才能使用。

  起变量名的时候要尽可能地见名知意。

  例如：String name ；使用name表示这个空间名字，即说明这个空间存放的姓名。

​ 变量在使用时，必须先给变量空间存放数据，即初始化。同时变量也有自己的生命周期（作用域问题）。

常量池的值有就直接用，没有就创建，注意常量池基础数据很多，开发时不考虑它的大小和多少，以及内存优化问题。

下面我们说的是Java中的数据类型 。

数据类型有基础的数据类型和引用的数据类型，

基本的数据类型有数值型，字符型（char），布尔型(boolean)

数值型分为：整数类型（byte ,short,int long ）浮点类型（float ,double）

引用数据类型：类（class） 接口（interface） 数组（[]） String

整数的话，一般默认的是int类型的数字，浮点数的话，默认的是double类型的

如果你想使用long类型的整数的话，long we=1234455L(大小写L都是可以 推荐使用大写)

如果你想使用float 单精度的浮点数的话 float f=12.34f;

1、布尔类型 boolean

boolean类型通常用于逻辑运算和程序流程控制。

boolean 类型数据只允许取值true或 false(不可以使用0 或非0的整数来代替true和false,区分于C语言)。

boolean flag;
flag = true;
System.out.println("flag"+ flag);

2、char类型

char用来存储通常意义上的字符，char占两个字节；范围是==[0,65535],前256 (2^16)==个表示 特殊字符 ，通常用单引号包裹''。char类型也是可以表示汉字的

例如：char c = ‘A’; char c2 = ‘传’; char c3=97;

java字符采用Unicode编码，可用十六进制编码形式表示。 char c1 = ‘\u0061’;//a

3、转义字符

有些符号在Java语言中有独特意义，当需要使用原本意义的时候需要，转义表示。例如：键盘上的制表符tab键。可以使用 ‘\t’表示。如双引号，在Java中使用双引号表示字符串，若想使用双引号本身含义，即可使用’\”’表示。

4、字符编码表（ASCII）

字符编码表（ASCII）：一张存放所有字符与整数的对应关系的表。整数可以通过这样的形式存储了。（计算机只识别二进制）。A 65 啊 97

例如：‘A’-----> 65

‘B’----->66

‘a’------>97

‘b’------>98

所以当把一个整形赋值给char的时候，计算机会查询整数对应的字符，将这个字符存在char空间里。例如：char ch = 65；其实是将A存放在ch中。

5、String类型

String不属于基本数据类型;但和字符有一定的联系。String是一个类（java语言里的最小单元），表示字符串；就是一串字符，字符串用""包裹起来，连接字符用+。

String str1 = "这是一个字符串";
String str2 = "这是一个字符串";
String str3 = new String("这是一个字符串");
String str4 = new String("这是一个字符串");

String的equals方法源码分析（这个看不懂的话，也没有关系，在之后还会详细的说明一次 ）

需要记得的是String类程序了Object类（根类）的equals()方法

一个类，你没有父类的话，就会给你一个默认的父类，就是Object类

你有父类的话，就按照你的父类 Object是所有类的根类

public boolean equals(Object anObject) {
	if (this == anObject) {// 地址
    	return true;// 地址一样本身就是一个东西
    }
    if (anObject instanceof String) {// 类型是否一致
		String anotherString = (String)anObject;// 强制转化
        int n = value.length;// 当前对象子串的长度
        if (n == anotherString.value.length) {// 目标子串的长度
        	char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {// 循环比较字符串的每一位
            	if (v1[i] != v2[i])
                	return false;// 不一样就返回false
            	i++;
            }
                return true;// 每一位都一样 返回true
        }
	}
	return false;// 类型不同也是错的
}

6、整数类型

整型数据根据数据范围不同，需要使用不同的关键字来表示。

byte、short、int、long这四个关键字都可以在内存中开辟出存放整型数据的空间

byte(1个字节） short(两个字节) int(四个字节) long(8个字节 )

JAVA语言整形的四种表现形式

二进制整数，以0b或0B开头，如：int a = 0B110;（不要超过范围）

十进制整数，如：int a = 17;

八进制整数，要求以0开头，如 int a = 012;

十六进制整数，要求0X或0x开头，如int a = 0x12;

浮点类型(float、double)

float：单精度浮点数 4个字节 double :8个字节

Java浮点类型常量有两种表示方式：

• 十进制形式： 例如：3.14 ，168.0， .618
• 科学计数法形式： 例如：3.14e2， 3.14E2， 1000E-2

Java浮点型常量默认是double，则要声明一个常量为float型，则需在常量后加上f 或 F,

如：double pi = 3.14;//正确

float pi = 3.14F;//必须加上f，或转型 float pi3 = (float)3.14;

注意：Java里只有浮点型的变量才可以接受科学计算式结果：

int num = 314E2; //错误；num为int类型，不可以使用科学计数法。

java数据存储区域简述

1. 寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.
2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中(对象可能在常量池里)（字符串常量对象存放在常量池中。）
3. 堆：存放所有new出来的对象。
4. 静态域：存放静态成员（static定义的）
5. 常量池：存放字符串常量和基本类型常量（public static final）
6. 非RAM存储：硬盘等永久存储空间

栈，堆和常量池，对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

垃圾回收站（GC）：会检查托管堆中是否有应用程序不再使用的任何对象。如果有，他们的内存就可以回收。

1.垃圾回收器开始执行时，垃圾回收器沿着线程栈上行以检查所有根（然后遍历所有类型对象上的所有根），如果发现一个根引用了一个对象，就在对象的“同步块索引字段”上开启一个位（对象就是这样标记的），如果对象里又引用有其他对象，则会遍历所有对象以标识。检查好所有根之后，堆中将包含一组已标记和未标记的对象。

2.垃圾回收器线性遍历堆，以寻找未标记对象的连续内存。如果发现的内存块比较小，垃圾回收器会忽略它、们。但是，如果发现大的、可用的连续内存块，“垃圾回收器会把非垃圾的对象移动到这里以压缩堆”。 最后记得重新分配地址存根

对于基础的变量和常量：变量和引用存储在栈中，常量存储在常量池中。

有一个常见的面试题？

String s = new String(“xyz”);产生几个对象？一个或两个，

如果常量池中原来没有”xyz”,就是两个对象。常量池有的话，就是一个。

数据类型的转换为：

分为隐式类型转换：小类型到大类型，会自动地进行转换

int i = 123;
long l = 6777;
l = i;

显式类型转换：大类型到小类型，需要强制进行类型转换

double d = 3.14;
float f = (float) d;

byte,short,char在参与运算的时候，会转为Int类型的数据

下面到我们的算术运算符

+，-,*,/,%,++,–

+号的作用：字符串的拼接，加号

++,–,放在前面使用的话，先增加，减少在使用

++,–放在后面使用的话，就是先使用，在进行增加，减少

赋值运算符

+=，==，-=，*=， /=，

int a=3;

a+=4;//意思就是a=a+4;

赋值运算符隐含了一个强制类型的转换

比较运算符就是>,>=,<,<=,这个

逻辑运算符：&，|，&&，||,^,!

&： 全真为真，有假则假
| ：有真为真，全假都为假
&& 和|| 短路与和短路或 左边满足判断条件，右边就不执行判断了
&&： 前一个为假的话 后面的不执行
|| ： 前一个为真的话 后面的不执行

^:不同为1，相同为0

！： 进行取反，真的变成假的，假的变成真的

位运算符：>>,<<,<<<,

常见的面试题 最有效率运算2乘以8，通过位移运算。2<<3

左移的话： 移一位，扩大2倍，

右移一位的话，缩小2倍

无符号的右移是 不关乎符号

下面来几个常见的面试题：

交换两个数的值

// 任何一个数^一个数两次得到它本身
// 通过第三方变量的形式进行置换。
int a = 3, b = 7;
int temp = a;
a = b;
b = temp;

// 通过和的形式。有个弊端，两个数据较大，可能会超出int范围。
a = a + b;//a = 3 + 7;
b = a - b;//b = 3 + 7 - 7； b = 3;
a = a - b;//a = 3 + 7 - 3; a = 7;

// 技巧。异或。
a = a ^ b;// a = 3 ^ 7;
b = a ^ b;// b = 3 ^ 7 ^ 7;
a = a ^ b;// a = 3 ^ 7 ^ 3;

幂运算：

使用Math.pow(a,b)来计算$a^b$ ，a和b是方法pow的两个未知变量。

• ​
  /**

   - 获取当前时间，并且截取时分秒。
     */
     public class 显示时间 {
     public static void main(String[] args) {
   
   // 获取格林威治时间距今的  毫秒值
   long totalMillSeconds = System.currentTimeMillis();
   // 获取格林威治时间距今的  秒值
   long totalSeconds = totalMillSeconds / 1000;
   // 显示的秒值
   long currentSecond = totalSeconds % 60;
   // 获取格林威治时间距今的  分钟值
   long totalMinutes = totalSeconds / 60;
   // 显示的分钟值
   long currentMinute = totalMinutes % 60;
   // 获取格林威治时间距今的  小时值
   long totalHours = totalMinutes / 60;
   // 显示的小时值
   long currentHours = totalHours % 24;
   
   System.out.println("当前时间是："+(8+currentHours)+":"+currentMinute+":"+currentSecond+" GMT");
   }
   }
  

  产生随机数的

/**

- 产生随机数
  */
  public class 产生随机数 {
  public static void main(String[] args) {

// 产生两个随机数
int number1 = (int) (Math.random() * 10);
int number2 = (int) (Math.random() * 10);
// 输出
System.out.println("number1 = " + number1);
System.out.println("number2 = " + number2);
}
}

好啦，这期的到这里就结束了

本人的知识水平有限，如果有错误或者总结不足的地方欢迎指出，大家一起学习