JAVA基础学习

最新推荐文章于 2024-08-07 08:53:05 发布

weixin_懂否

最新推荐文章于 2024-08-07 08:53:05 发布

阅读量229

点赞数

分类专栏：笔记文章标签： github macos visual studio code windows sublime text

本文链接：https://blog.csdn.net/weixin_48064839/article/details/106746542

版权

笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

java基础学习

JAVA发展历程

1995年sun公司发布java1.0版本
1997年sun公司发布java1.1版本
1998年sun公司发布java1.2版本
2000年sun公司发布java1.3版本
2002年sun公司发布java1.4版本
2004年sun公司发布java5版本
2006年sun公司发布java6版本
2009年oracle公司收购了sun公司，并于2011年sun公司发布java7版本
2014年sun公司发布java8版本
2017年sun公司发布java9版本
2018年sun公司发布java10版本

计算机基础知识

HEX 十六进制
DEC 10进制
OCT 八进制
BIN 二进制

计算机存储单元

bit (位) 一个数字0或者一个数字1代表一位

byte (字节) 1byte = 8 bit ，字节是计算机存储的最小单位

1 kB = 1024 byte
1MB =1024 KB
1GB =1024 MB
1TB =1024 GB 多用于电脑硬盘
1PB =10Z4 TB 用于服务器
1EB =1024 PB
1ZB =1024EB

window操作系统

命令提示符

win + r 输入cmd 命令提示符进入黑窗口（不区分大小写）

盘符名称: 回车切换盘符
cd 空格文件名称回车进入文件夹
cd 空格 … 返回上一级目录
cd 空格文件夹1\文件夹2 进入多级文件夹
dir 回车查看当前内容
cls 回车清屏
exit 回车退出黑窗口

JAVA环境搭建

jdk : JAVA 程序开发包

jre : JAVA 运行时环境

jvm JAVA虚拟机

三者之间的关系

在这里插入图片描述

JDK的下载与安装

JAVA环境变量配置

编写第一个JAVA程序Hello Word

程序开发步骤说明

JAVA程序开发三步骤编写源程序。编译源程序。运行

javac.exe :编译器

java.exe L解释器

注意：源程序后缀名必须以 .java结尾，经过javac.exe 编译为字节码文件（.class文件）然后在jvm 中运行

编写源程序

public class HelloWord{  //public class 后面代表定义一个类名称
  public static void main (String[]args){ //main方法 ，程序执行的起点
      System.out.print("hello word");//代表打印输出
  }
}

2.编译源程序

javac HelloWord.java 生成HelloWord.class文件

3.运行

java HelloWord 输出hello word

程序注释

单行注释 //
多行注释 /* */ (区块注释)

关键字和标识符

关键字：有特殊含义的，被保留的，不随意、被使用的字符。

特点：1，完全小写的字母。

2，在增强的记事本当中（notePad++）有特殊颜色的字符.

标识符：程序当中自定义的名称。

命名规则：硬性要求

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

命名规范：软性要求
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
方法名规范：同变量名

常量

概念：常量是指java运行期间固定不变的量。

分类：

字符串常量：凡是用双引号引起来的部分，都是字符串常量（字符串两个双引号之间内容可以为空）
整数常量：直接写上的数字，没有小数点。
浮点数常量：直接写上的数字，有小数点。
字符常量：凡是用单引号引起来的单个字符，都是字符常量（字符常量单引号之间不能为空，至少有一个空格）
布尔常量：布尔常量只有两种类型 true 和 falise
空常量 null 代表没有任何数据（空常量不能被打印输出）

基本数据类型

基本数据类型（四类八种）

整数类型：byte（1字节 -128-127） short（2字节） int（4字节） long（8字节）

浮点型：float （4字节）double（8字节）

字符型：char（2字节 0-25535）

布尔型：boolean（1字节）

注意：

字符串不是基本类型。而是引用数据类型。
浮点型，可能只是一个近似的值，不是一个精确的值。
数据范围和字节数可能不一定相关，例如float的数据范围比long类型的大，但是f;oat是4字节，long是8字节。
float 当中默认类型是double，如果要使用float，需要在浮点数后面加上f(推荐F大写)。整数类型的默认类型是int。如果要使用long类型，必须在整数后面加上l(L推荐大写)。

引用数据类型：类，数组，接口，字符串

变量(variable)

概念：程序运行期间，程序可以发生改变的量。

格式：

1，数据类型变量名称 //创建了一个变量

变量名称 = 变量值 //赋值：将右边的值赋值交给左边的变量

演示：

public class Variavle{
  public static void mian (String[]args){
    int num; //创建一个变量
    num = 10;//给变量赋值
    System.out.println(num);//打印输出
  }
}

2，数据类型变量名称 = 数据值 //在创建一个变量的同时，立即放入一个指定的数据值

演示：

public class Variavle{
  public static void mian (String[]args){
   int num = 10;//创建变量的同时直接给变量赋值
    System.out.println(num);//打印输出
  }
}

注意：在给变量赋值时，不能超过数据类型的数据范围，否则会数据异常。

演示：

public class Variavle{
  public static void mian (String[]args){
     boolean var1 = false;
     boolean var2 = var1;//将一个变量的数据内容，赋值叫给另一个变量，右侧的var1 变量值已经纯在，里面装的是false的布尔值，将右侧变量里面的false值，向左交给var2变量进行存储。
     System.out.println(var2);
  }
}

使用变量注意事项

如果创建多个变量，那么变量之间的名称不能重复。
对于float和double类型来说，字母F和L不能丢掉。
如果使用byte short 类型的变量，那么右侧的数据值不能超过左侧的范围
没有进行赋值的变量不能直接使用，必须赋值后才能使用。
变量使用不能超过作用域的范围【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止。

可以通过一个语句创建多个变量，但是不推荐。

示例1：

int a,b,c;
a = 10;
b = 20;
c = 30;

示例2

int x = 100,y = 200,z = 300; //直接赋值

数据类型的转换

自动转换（隐式）

当数据类型不一样时，将会发生数据类型的转换。

特点：代码不需要特殊处理，自动完成。

规则：数据范围从小到大。

演示：

long num = 200; //一个等号代表赋值，将右边的int常量交给左边的long类型进行赋值。int -> long 符合自动转换从小到大的规则
System.out.println(num);

强制转换

特点：代码需要进行特殊的格式处理，不能自动完成。

格式：范围小的类型范围小的变量名 = （范围小的类型）原本范围大的数据

示例：

int num = (int)100L; //左边是int类型，右边是long类型，将long类型赋值给int类型，不符合数据类型从小到达的转换规则，需要进行强制转换。
System.out.println(num);

注意事项

1.强制类型转换一般不已推荐使用，因为可能造成数据溢出。精度损失

数据溢出示例

int num = (int)6000000000F;//右侧的数值超出了左侧int类型的取值范围。所以会造成数据溢出
System.out.println(num);

精度损失示例

int num = (int)3.99;
System.out.println(num);//3 这并不是四舍五入，小数点后边的数都会被舍弃掉，所以会造成精度损失。

2.byte/short/char 这三种类型可以进行数学运算，例如加法运算

示例

char zifu  =  'A'; 
System.out.println(zifu + 1);//66 计算机底层（二进制）会用一个数字来代表字符A，一旦char类型进行数学运算，那么字符就会根据一定的规则翻译为数字

3.byte /short/char 这三种类型，一旦进行数学运算都会首先被提升为int类型，再进行运行算。

示例

byte num = 20;
byte num2 = 30;
int result1 = num + num2;
System.out.println(result1);
//或者进行强制转换
byte num3 = 30;
byte num4 = 40;
byte num5 = (byte) (num3 + num4);//注意，右侧的结果值一定不能超过左侧数据类型的取值范围
System.out.println(num5);

4.布尔类型不能进行数据类型转换。

ASCLL编码表

48 ‘0’

65 ‘A’

97 ‘a’

2013 ‘中’

运算符(Operator)

算术运算符

加 +
减 -
乘 *
除 /

取模 %

示例：

public class demo1{
  public static void main(String[]args){
     int x = 20;
     int y = 5;
     System.out.print(x + y); //25
     System.out.print(x - y); //15
     System.out.print(x * y); //100
     System.out.print(x / y) //4
     System.out.print(x % y); //0
  }
}

注意事项

一旦运算中有不同类型的数据，那么结果将是数据类型范围大的那种。

四则运算中加号的三种用法
1. 对于数值来说，那就是加法
2. 对于char类型来说，运算之前，char类型会首先提升为int类型在进行计算。（ASCLL 和Unicode码表）
3. 对于字符串String 来说，“+” 代表字符串的连接工作。任何数据类型和字符串进行连接的时候结果都会变成字符串。
  
  示例
```
public class demo1{
  public static void main(String[]args){
     String str = "java";
     System.out.println(str + 20); //java20
  }
}
```
  - 自增运算符 ++
  - 自减运算符 –

含义：让一个变量增加一个数字1 ，或者让一个数字减少一个数字1.

用法：写在变量之前，或者写在变量之后。例如：num ++ ; num --; ++ num ; --num

使用方法：

1.自己单独使用，不和其他步骤进行操作，自己独立成为一个步骤。

2.混合使用，和其他操作混合，例如：赋值混合，打印混合

使用区别

1：在单独使用的时候，前++ 和后++完全没有什么区别，结果是一样的。

2.在混合使用的时候，有重大区别

A:如果是前++，那么变量马上加一，然后结果马上进行使用。【先加后用】

B:如果是后++，那么首先使用变量本身的数值，然后在进行加一。【先用后加】

自减反之。

注意事项

只有变量才能自增自减运算，常量不能发生改变，所以不可用。

示例

 public class demo1{
     public static void main(String[]args){
        int num = 10;
        int num1 = 10;
      System.out.println(++num);//11
      System.out.println(num1++);//10
      System.out.println(--num); // 10
      System.out.println(num1--);//11
   }
 }

比较运算符

等于 ==
( >=) 大于等于
< = 小于等于
(>)大于
(<) 小于
！= 不等于

注意事项

1，比较运算符的结果一定是一个boolean值

2.如果进行多次判断，不能连着写、如 a > b > c

示例

 public class demo1{
     public static void main(String[]args){
        int num = 10;
        int num1 = 11;
      System.out.println(num > num1);//false
      System.out.println(num < num1);//true
      System.out.println(num == num1); // false
      System.out.println(num >= num1); // false
      System.out.println(num <= num1); // true
      System.out.println(num != num1); // true
   }
 }

逻辑运算符

与 && （并且）都为true才是true

或 || (或者) 有一true则true

非 ! (否则) 有true则false ,反之为true

与或都具有短路效果，如果根据左边的代码已经可以判断出最终结果，那么右边将不再执行

注意事项

1.辑运算符直蹦只能用于boolean值

2.与或需要两边都要有boolean值，但取反仅仅需要一对

3，与或两种运算符，有多个条件时，可以连续写。

示例

System.out.println(true && false);//false
System.out.println(true ||flse);//true
System.out.println(!false);//true

赋值运算符

基本赋值运算符：= 将右侧的数据交给左侧的变量

例如：int x = 10

复合赋值运算符：

+= a += 3 相当于 a = a + 3
-= a -= 3 相当于 a = a - 3
*= a *= 3 相当于 a = a * 3
/= a /= 3 相当于 a = a / 3
%= a % 3 相当于 a = a % 3

注意事项

1，只有变量才可以使用赋值运算符

2 .复合赋值运算符中隐含着强制类型准换

示例

public class operaor{
  public static void main(String[]args){
      int a = 10;
      int b = 10;
      int c = 10;
      int d = 10;
      int e = 10;
      a += 3;
      b -= 3;
      c *= 3;
      d /= 3;
      e %= 3;
       System.out.println(a);//13
       System.out.println(b);//5
       System.out.println(c);//30
       System.out.println(d);//3
       System.out.println(e);//1
      
    }
  }

三元运算符

一元运算符：只需要一个数据就可操作的运算符。如：自增自减运算符，取反

二元运算符：需要两数据就可操作的运算符。如：加法。赋值

三元运算符：需要三个数据才可以操作的运算符。

格式：

数据类型变量名称 = 判断条件？表达式1 ：表达式2；

流程：

首先判断表达式是否成立

如果成立为true，那么将表达式一赋值给左边的变量。

如果为false，那么将表达式二赋值给左边的变量。

注意事项

1，必须同时保证表达式A表达式B复合左边数据类型的要求。

2，三元运算符的结果必须被使用。

示例

int a = 11;
int b = 12;
int max = a > b ? a : b;//判断a >b 是否成立，如果成立将a 赋值给max，如果不成立将b赋值给max.
System.out.println(max);//12

方法入门

格式：

public static void 方法名称(){

    方法体
}
//方法名称的命名和变量一样，使用小驼峰式。
//方法体可以包含任意条语句

注意事项

1.方法定义的先后顺序无所谓。

2.方法定义好了之后，不能产生嵌套包含关系。

3.方法定义好以后不能直接使用，如果需要执行，需要进行方法的【调用】。

示例

public static void famer(){
 System.out.println("种菜");
   
}

调用方法

格式

public class operaor{
  public static void main(String[]args){
      方法名称();
       }
     }

示例

public class operaor{
  public static void main(String[]args){
      famer();
       }
   public static void famer(){
     System.out.println("种菜");
   
       }
     }

JDK9的新特性

1.Jshell 插件使编码更轻松。

2.对于byte .short .char 类型来说如果右侧赋值的数值没有超过范围，那么javac编译器将会隐含的加上一个(byte )

(short) (char).

A:如果没有超过左侧的范围，那么编译器会默认加上强转。

B:如果超过了左侧的范围，那么编译器会报错。

示例：

byte num = 20;//右侧是一个int变量，但是没有超过左侧的范围，所以不会报错。否则，会报错。
System.out.println(num);

3.在给表达式赋值的时候，如果右侧的表达式都是常量没有变量，那么编译器将会直接将若干个表达式直接计算出结果。

这称为表达式的常量优化，注意，一旦表达式中出现变量，这种优化就不能够激进行。

short a = 10;
short b = 15;
short c = a + b;//错误写法
System.out.println(c);

short d = 10 + 15;//正确写法
System.out.println(d);

流程控制

顺序结构

从上往下按照顺序执行

选择结构

if语句第一种结构:单if语句

if(关系表达式){
 语句体;
}
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200614152613233.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODA2NDgzOQ==,size_16,color_FFFFFF,t_70#pic_center)

- 执行流程

  1.首先判断关系表达式的关系是true 还是false

  2.如果是true就执行语句体，如果是false就不执行语句体。

代码实现：

int age = 18;
if (age > 19){
 System.out.println("上网吗网游戏");
}
  System.out.println("回家吃饭");

if语句第二种结构。多if语句

if(关系表达式){
 语句体1;
}else{
 语句体2;
}

1.首先判断关系表达式的结果是true还是false

2.如果是true，执行语句体1，如果是false执行语句体2.
在这里插入图片描述

代码实现：

//判断数字实奇数还是偶数
int a = 10;
if (a % 2 == 0){
 System.out.println("偶数")
}else{
  System.out.println("奇数")
}

if语句第三种结构 if elseif else

if(判断条件1){
  执行语法1;
}else if(判断条件2){
  执行结果2;
}else if(判断条件3){
  执行结果3;
}else{
  执行语句4;
}

在这里插入图片描述

执行流程

1.首先判断表达式是true还是false

2.如果是true执行语句体1.

3.如果是false就继续判断语句体2，看结果是true还是false

4.以此类推，知道语句执行完毕。

代码实现：

//x和y 的关系满足如下
//如果 x > 5 ;那么 y = 2x + 1
//如果 3 < x < 5 ;那么y = x - 2;
//如果  x > 5;那么 y = 3x
int x = 7;
if(x > 5){
 y = 2 * x + 1;
}else if(x > 3 %% x < 5){
  y = x - 2;
}else {
  y = 3 * x;
}
System.out.prinyln("结果是" + y);

使用三元运算符和标准的if语句分别实现，两个数的最大值

int x = 10;
int y = 12;
int max = x > y ? x : y;//使用三元运算符判断最大值。
int max1;
if(x > y){//使用if else语句判断两个数的最大值
  max1 = x;
}else{
 max1 = y;
}
System.out.println(max);
System.out.prinlm(max1);

选择语句—switch

格式：

switch (表达式){
 case 常量值:
 语句体1;
 break;
 case 常量值2:
 语句体2;
 break;
 ....
 default:
  语句体n;
  break;
}

执行流程：

首先计算出表达式大的值。
其次和case依次做比较，一旦有对应的值，就会执行相应的语句，一旦遇到break,就会结束
最后如果所有case都和表达式的值不铺陪，那么将默认执行default中的语句体，然后结束程序。

流程图

在这里插入图片描述

代码实现：

public class DemoSwitch{
 public static void main(String[]args){
  int num = 3;
  switch(num){
          
   case 1:
   Sysrem.out.println("星期一");
   break;
   
   case 2:
   Sysrem.out.println("星期二");
   break;
   
   case 3:
   Sysrem.out.println("星期三");
   break;
   
   case 4:
   Sysrem.out.println("星期四");
   break;
   
   case 5:
   Sysrem.out.println("星期五");
   break;
   
   case 6:
   Sysrem.out.println("星期六");
   break;
   
   case 7:
   Sysrem.out.println("星期日");
   break;
   
   default:
   System.out.println("数据不合理");
   break;//最后一个break可省略，但强烈建议不省略。
  }
 }
}

注意事项：

1.多个case后面的数值不能重复。

2.switch后小括号当中只能放一下数据类型

 基本数据类型：byte/short/char/int

 引用数据类型：String 字符串 enum 枚举

3.switch 语句可以很灵活，前后顺序可以颠倒，break可以省略。

【匹配哪一个case，就从哪一个case向下执行，直到遇到了break或者整体结束为止】

public class DemoSwitch{
 public static void main(String[]args){
  int num = 2;
  switch(num){
          
   case 1:
   Sysrem.out.println("你好");
   break;
   
   case 2:
   Sysrem.out.println("我好");
 
   
   case 3:
   Sysrem.out.println("大家好");
   break;
   
   default:
   Sysrem.out.println("输入错误"); //输出 我好 大家好
   break;
     }
   }

循环结构

循环结构的基本组成部分，一般可以分为四部分

初始化语句，在循环开始的最初阶段，而且只执行一次。
条件判断，如果条件成立，则循环继续，如果不成立，则退出循环。
循环体，重复要做的事情内容，若干语句
步进语句，每次循环之后进行扫尾工作，每次循环都要执行一次。

for循环语句格式
```
for(1初始化表达式;2布尔表达式;4步进表达式){
  3循环体;
 }
```
执行流程

1234 -->234 -->234…直到2不满足为止

1.负责完成循环变量的初始化。

2负责判断是否满足循环条件，不满足退出循环。

3.具体执行的语句

流程图：

代码实现：
```
for(int i = 1; i <= 100; i++){
 System.out.println("我错了" + i);
}
```
while 循环有两种格式。标准格式和扩展格式

标准格式
```
while(条件判断){
  循环体;
  }
```
扩展格式
```
初始化语句;
while(条件判断){
  循环体;
  步进语句;
}
```
流程图：

代码实现：
```
int i = 1; //初始化语句
while (i <= 10){ //条件判断
 System.out.println("错了")//循环体
  i++;//步进语句
}
```
do- while循环的标准格式与扩展格式

标准格式
```
do{
循环体;
}while(条件判断);
```
扩展格式

  1初始化语句;
  do{
   3循环体;
   4步进语句；
  }while(2条件判断)

执行流程

134 -->234–>234…直到2不满足为止

流程图

在这里插入图片描述
注意：do -while 循环至少执行一次。

代码实现

int i = 0;//初始化语句
do{
 System.out.println("打印输出");//循环体
 i++;//步进语句
}while(i <= 10);//条件判断

练习

1.求出一到一百之间的偶数和

思路：需要一个变量进行累加操作

public class add{
  public static void main(String[]args){
    int sum = 0;
    for(int i = 1; i <= 100; i++){
        if(i % 2 == 0){
          sum += i;
        }
    }
    System.out.println(sum);
  }
}   //for循环

public class add{
  public static void main(String[]args){
      int i = 1;
      int sum = 0;
       while(i <= 100){
        if(i % 2 == 0){
          sum += i;
        }
        i++;
       } 
          System.out.println(sum);
   }
   }   //while循环

   public class add{
    public static void main(String[]args){
      int i = 1;
        int sum =0;
        do{
            if(i % 2 == 0){
                sum += i;
             }
            i++
        }while(i <= 100);
    }
    }   //do-while循环

三种循环的区别

如果判断从来没有满足过，那么while循环和do-while 循环将会执行0次，而do-whike 循环至少会执行一次。
for循环变量在小括号内部定义，只有循环内部才可以使用，而while和do-while循环定义在外部，所以出循环之后还可以继续使用。

循环控制–break

1.可以用在switch语句中，一旦执行，整个switch语句立马结束。

2.可以用在for循环中，一旦执行，整个循环立刻结束。

注意如果次数确定的场合多用for循环，否则用while循环

循环控制—continue

1.一旦执行，立刻跳过当前次循环，开始下一次循环。

代码实现：

for(int i = 1; i <= 10; i++){
  if(i == 4){
   continue;
  }
}
Ststem.out.println("到了" +i+ "了");

死循环

含义：永远停不下来的循环

格式

while(true){
 循环体;
}

嵌套循环

含义：循环嵌套循环

代码实现

//输出几时几分
for(int hour = 0; hour < 24; hour++){
 for(int minute = 0; minute < 60; minute++){
  System.out.println(hour +"点" + minute + "分");
 }
}

 if(i % 2 == 0){
      sum += i;
    }
    i++;
   } 
      System.out.println(sum);

}
} //while循环


```java
   public class add{
    public static void main(String[]args){
      int i = 1;
        int sum =0;
        do{
            if(i % 2 == 0){
                sum += i;
             }
            i++
        }while(i <= 100);
    }
    }   //do-while循环

三种循环的区别

如果判断从来没有满足过，那么while循环和do-while 循环将会执行0次，而do-whike 循环至少会执行一次。
for循环变量在小括号内部定义，只有循环内部才可以使用，而while和do-while循环定义在外部，所以出循环之后还可以继续使用。

循环控制–break

1.可以用在switch语句中，一旦执行，整个switch语句立马结束。

2.可以用在for循环中，一旦执行，整个循环立刻结束。

注意如果次数确定的场合多用for循环，否则用while循环

循环控制—continue

1.一旦执行，立刻跳过当前次循环，开始下一次循环。

代码实现：

for(int i = 1; i <= 10; i++){
  if(i == 4){
   continue;
  }
}
Ststem.out.println("到了" +i+ "了");

死循环

含义：永远停不下来的循环

格式

while(true){
 循环体;
}

嵌套循环

含义：循环嵌套循环

代码实现

//输出几时几分
for(int hour = 0; hour < 24; hour++){
 for(int minute = 0; minute < 60; minute++){
  System.out.println(hour +"点" + minute + "分");
 }
}

weixin_懂否

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础学习

java基础学习JAVA发展历程1995年sun公司发布java1.0版本1997年sun公司发布java1.1版本1998年sun公司发布java1.2版本2000年sun公司发布java1.3版本2002年sun公司发布java1.4版本2004年sun公司发布java5版本2006年sun公司发布java6版本2009年oracle公司收购了sun公司，并于2011年sun公司发布java7版本2014年sun公司发布java8版本2017年sun公司发布java9版本201
复制链接

扫一扫