Java学习笔记1：入门+基础语法

于 2025-02-26 17:06:55 发布
阅读量618 收藏 17
点赞数 10
文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53008791/article/details/145883411
版权

Java入门

​

0除任何数都为0， 任何数除0都报错 （前端报infinity，后端报异常）

JDK和环境配置

JDK版本

1、本地安装版本：21.0.6
2、测试jdk是否安装成功：在cmd命令窗口输入java -version,javac -version
3、java.exe：执行工具
4、javac.exe：编译工具 
5、老版本的JDK需要手动配置环境变量
	①此电脑-属性-高级系统属性-高级-环境变量-用户环境变量
	②把路径粘贴到环境变量中（一般在jdk的bin目录）

JDK组成

JVM：java虚拟机，真正运行java程序的地方；
核心类库： java自己写好的程序，给程序员自己的程序调用的；
JRE（JVM+核心类库）：java的运行环境；
开发工具：java、javac...

JDK和JAVA_HOME环境变量配置

1、JDK：老版本的JDK需要手动配置环境变量，新版本会在安装时自动配置
	①此电脑-属性-高级系统属性-高级-环境变量-用户环境变量
	②把路径粘贴到环境变量中（一般在jdk的bin目录）
2、JAVA_HOME：用于其他技术通过这个环境变量找到jdk

命令窗口常用命令

dir：查看当前路径下的文件信息
cd：
	1、进入单极目录：cd 目录名
	2、进入多级目录：cd D:\目录名\目录名
	3、回退到上一级目录：cd..
	4、回退到盘符根目录：cd\
cls：清屏

程序命名：

1、文件名要和类名一致，否则运行程序时会报错；
2、文件内标点符号不能省略；

IDEA管理java程序的结构

project：项目/工程
module：模块
package：包
class：类

IDEA常见操作

  文件重命名：选中当前文件，Refactor -- Rename  
  修改模块：选中当前模块， Refactor -- Rename --Rename module and directory
  导入模块： 
  	1、在idea中，file -- new -- module from existing sources(从已经存在的资源中找模块) -- 选中XXX.iml文件(文件图标下方有个黑方块)打开
  移除模块：选中模块 -- remove module (工程界面删除，本地磁盘还存在)
  打开工程：file -- open -- 选中工程打开

Java开发步骤

project -> module -> package -> class 
1、新建项目：可以创建多个模块
2、新建模块(文件-新建-module-java )：可以创建多个包
3、新建包（项目-src-新建包）：可以创建多个类
4、新建类（项目-src-包-新建类）

Java开发快捷键

main/psvm、sout ：快速键入相关代码
ctrl + D ：复制当前行数据到下一行
ctrl + alt + L ：格式化代码
alt + shift + ⬆ / alt + shift + ⬇ ：上下移动当前行代码
ctrl + / 、ctrl + shift + / ：对代码进行注释

Debug工具使用步骤

在这里插入图片描述

###Java基础语法

Java字面量

整数、小数、字符('',有且只能有一个字符)、字符串("")、布尔值、空值(null)
特殊字符：
	\n 代表换行的意思
	\t 代表一个tab空格的意思

Java变量

数据类型 变量名 = 数据
整形： int age = 23
小数： double score = 99.5
字符： char ch = 'a' a-97 A-65 0-48

不区分类型，变量名在同一范围内不能重复

Java标识符

标志符就是名字，我们写程序会起一些名字，如类名、变量名等都是标识符
要求及规范：
	由数字、字母、下划线和美元符号等组成
	不能以数字开头
	不能用关键字作为名字
	区分大小写

进制

十进制转二进制：除2取余法
八进制：每三位作为一个编码,最小数0，最大数7，共八位
	(十进制)97 --（二进制）01100001 -- (八进制141)01 100 001
十六进制：每四位一个编码,最小数0，最大数15，0-9 A-F代表十六进制
	(十进制)97 -- 十六进制(61) 0110 0001 
	(十进制)250 -- 十六进制(FA) 1111(15/F) 1010(10/A)
练习：
		//二进制 0B开头 0B 11011001
        System.out.println(0B11011001); //217
        //八进制 0开头 0 141
        System.out.println(0141); //97

        //十六进制 0x开头 0x FA
        System.out.println(0xFA); //250
数据单位：
    1B = 8b
    1KB = 1024B
    1MB = 1024KB
    1GB = 1024MB
    1TB = 1024GB

数据类型-基本数据类型

   	 类型   占用字节数         	数据范围  默认int
整型：默认int
	1、byte       1           	-128~127
	2、short      2				-32768~32767
	3、int		 4				-2147483648~2147483647
	4、long		 8				-9223372036854775808-9223372036854775807
浮点数：默认double
	5、float		 4				1.401298 E -45 ~ 3.4028235 E +38
	6、double  	 8				4.9000000 E -324 ~ 1.797693 E +308
字符型：
	7、char  	 2				0-65535
布尔型：
	8、boolbean	 1				true/false
	
	整型使用：年龄可用byte存储 一般开发用int 更多用long
	长整型使用：
	//随便写一个正兴字面量默认是int类型 超过int类型 没有超过long类型
    //如果希望随便写一个整形变量默认是long类型的话，需要在后面加上L/小写l
    //  long e = 44444444477777; 越界了
        long f = 123456789L;

	浮点数使用(float):
	//随便写小数字面量，默认是double类型，如果希望小数是float类型，后面加F/f

    小范围类型的变量可以转换成大范围类型的变量
        byte a = 12;
		int b = a;
		System.out.println(b); //12
	自动转换
        byte --> short --> int --> long --> float --> double
        char --> int

数据类型-引用类型

字符串类型：
String name = "张三"

表达式的自动类型转换

byte、short、char --> int --> long --> float --> double
表达式的最终结果类型由表达式中的最高类型决定；
在表达式中，byte、short、char是直接转换成int类型参与运算的；
    byte a = 10;
	int b = 20;
	long c = 30;
	long res = aa + bb + cc;
	System.out.println(res); //60

强制类型转换（ALT + Enter快捷键）
    数据类型 变量2 = (数据类型) 变量1 数据
    int b = 20
    byte a = (byte)b
强制类型转换可能造成数据溢出/丢失
浮点数强转整型，直接丢掉小数部分，保留整数部分返回
      	double r = 99.5;
        int rr = (int) r;
        System.out.println(rr); //99

基本的算术运算符、赋值运算符

+、-、*、/、%
+：例如：
    	int a = 10
        System.out.println(a + 'a'); // 107
        System.out.println('a' + a); // 107 字符a
        System.out.println("a" + a); // a10 字符串a
        System.out.println("abc" + a);// abc10
    
/：在java中两个整数相除结果还是整数， 例如：
public class YunSuan {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        double c = (double) a / b;
        System.out.println(a / b);// 3
        System.out.println(1.0 * a / b);// 3.3333333333333335
        System.out.println(c); // 3.3333333333333335
    }
}

自增/自减 ++/ --：
    放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算
            int a1 = 10;							int a1 = 10;
   	 		int res1 = a++;				  			int res =  ++a;
       		System.out.println(res1); //10			System.out.println(res) //11
			System.out.println(a1); //10			System.out.println(a1); //10
        
        
    放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1
          	int a1 = 10;							int a1 = 10;
   	 		int res1 = a--;				  			int res =  --a;
       		System.out.println(res1); //10			System.out.println(res) //9
			System.out.println(a1); //9			System.out.println(a1); //9
    
扩展赋值运算符：隐含了强制类型转换
+=: a+=b <==> a = (a的类型)(a+b)
-=: a-=b <==> a = (a的类型)(a-b)
*=: a*=b <==> a = (a的类型)(a*b)
/=: a/=b <==> a = (a的类型)(a/b)
%=: a%=b <==> a = (a的类型)(a%b)

逻辑运算符

&：逻辑与，多个条件必须为true，结果才为true; 2>1 & 3 >2 ---> true
|：逻辑或，多个条件有一个为true，结果就为true； 2>1 | 4 > 5 ---> true
!：逻辑非，取反运算
^：逻辑异或，前后条件的结果相同，就直接返回false，前后条件的结果不同，才返回true；
	异或举例：
		2>1 ^ 3>1 <---> false
		2>1 ^ 1>3 <---> true
		
//*************重点使用************ 短路与优先级高于短路或
&&：短路与，判断结果与'&'一样，过程却不同(左边为false，右边则不执行) 2>10 && 3 > 2 ---> false
||：短路或，判断结果与'|'一样，过程却不同(左边为true，右边则不执行) 2 > 1 || 3 < 5 ---> true

运算符的优先级

优先级					运算符
1						( )
2						!、-、++、--
3						*、/、%
4						+、-
5						<<、>>、>>>
6						<、<=、>、>=、instanceof
7						== 、!=
8						&
9						^
10						|
11						&&
12						||
13						?:
14						=、+=、-=、*=、/=、%=、&=

==================================================================================================================================================================================================================

工具包

System、String在JDK的java.lang包下，lang包是默认包，不需要我们导包。

util

import java.util.XXX;

java.util.Scanner

import java.util.Scanner;

public class KeyExample {
    public static void main(String[] args) {
//        键盘录入练习
        Scanner sc = new Scanner(System.in);
//        调用sc功能，接收键盘输入的数据
        System.out.println("请输入你的名字");
        String name = sc.next(); // String类型
        
        System.out.println("请输入年龄");
        int age = sc.nextInt();  // 整数类型
        
        System.out.println("您的姓名是：" + name + "，年龄为：" + age);
        sc.close();
    }
}

java.util.Random

在这里插入图片描述

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        Random rand = new Random();
        int num = rand.nextInt(10); //包前不包后 随机数区间为[0, 9)
        System.out.println("随机数：" + num);
    }
}

//猜数字游戏
package com.item.branchstructure;

import java.util.Random;
import java.util.Scanner;

public class GuessNumber {
    public static void main(String[] args) {
        Random rand = new Random();
        Scanner sc = new Scanner(System.in);
        int a = rand.nextInt(100) + 1;
        System.out.println("随机数为：" + a);
        while (true) {
            System.out.println("请输入一个数字：");
            int key = sc.nextInt();
            if (key > a) {
                System.out.println("猜大了");
            } else if (key < a) {
                System.out.println("猜小了");
            } else {
                System.out.println("猜对了，游戏结束");
                break;
            }
        }


    }
}

###程序流程顺序###

ctrl + alt + t 快捷键： 选中一段代码，执行快捷键，打开流程控制选择页面( if / switch / for / while … )

分支结构

  • if在功能上远远强大于switch
  • 当前条件是区间时，应使用if分支结构
  • 当前条件是一个一个值比较的时候，switch分支更适合：格式良好、性能较好、代码优雅

if

package com.item.branchstructure;

import java.util.Scanner;

public class BranchStructure1 {
    public static void main(String[] args) {
//        if分支用法
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入测量温度");
        double t = sc.nextDouble();
        if (t > 37) {
            System.out.println("温度过高");
        } else {
            System.out.println("温度正常");
        }
    }
    
}

switch

  • 表达式类型只能是byte、short、int、char、JDK5开始支持枚举，JDK开始支持String，不支持double、float、long类型
  • case给出的值不允许重复，且只能是字面量，不能是变量
  • 正常使用switch的时候，不要忘记写break，否则会出现穿透现象(只有在遇到break时才会退出分支，忘记写的话会打印一个或多个)
package com.item.branchstructure;

import java.util.Scanner;

public class BranchStructure1 {
    public static void main(String[] args) {
//    switch分支 用法
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的成绩：");
        int a = sc.nextInt();
        switch (a) {
            case 90:
                System.out.println("你的成绩是优秀");
                break;
            case 80:
                System.out.println("你的成绩是良好");
                break;
            case 60:
                System.out.println("你的成绩是及格");
                break;
            default:
                System.out.println("你的成绩是不及格");
                break;
        }

    }
}

循环结构

for

package com.item.branchstructure;

public class LoopStructure {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("循环控制" + i);
        }
    }
}

while

while(循环条件){
	循环体语句(被重复执行的代码);
	迭代语句;
}

//    while 循环
      int m = 0;
      while (m < 5) {
          System.out.println("while循环控制" + m);
          m++;
      }

do-while

最少执行一次

do{
    循环体语句;
    迭代语句;
} while (循环条件)
    
//  do While循环
	int n = 0;
	do {
	    System.out.println("do-while循环控制" + n);
	    n++;
	} while (n < 5);

死循环

while(true){
	System.out.println("while死循环控制");
}

循环嵌套

外一次，内一轮

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        System.out.print('*');
    }
    System.out.println();
}
/*
	****
	****
	****
*/

循环跳转关键字

  • break：跳出并结束当前所在循环的执行（只能用于结束所在循环，或结束所在switch分支的执行）
  • continue：用于跳出当前循环的当次执行，直接进入当前循环的下一次执行（只能在循环中进行）

###数组####

  • 数组就是一个容器，用来存储一批同种类型的数据。
int[] arr = {20, 30, 40, 50}; 
或 
int[] arr = new int[] {20, 30, 40, 50};

​	int表示类型
​	[]表示定义一个数组
​	arr表示数组名称
​	{}里的把内容表示数组内容

  • 静态初始化数组：定义数组时直接给数组赋值，

  • 动态初始化数组：定义数组时不存入数据，之确定数组的数据类型和数组长度

int[] arr = {20, 30, 40, 50}; 
System.out.println(arr);
/*
	[I@b4c966a  
		[ ---> 表示一个数组对象   
		I ---> 表示一个int类型  
		@b4c966a  ---> 指向一个对象地址
*/

// 动态初始化数组
int[] arr = new int[3]  //这时打印数组元素 三个元素都为0 
// **********注意*************************************************************
 	数据类型    					明细						默认值
    基本类型				byte、short、char、int、long 		0
    						   float、double					0.0
    						     boolean					false
    
    引用类型				类、接口、数组、String				null

数组的访问

数组名[索引]

数组名.length

访问数组时，索引超过数组最大的索引时，执行程序会报索引越界的错误。

数组的遍历

for循环、

 for (int i = 0; i < ages.length; i++) {
     System.out.println(ages[i]);
 }

####方法#####

方法的完整格式

修饰符	返回值类型	方法名(形参列表){
	方法体代码 //需要执行的功能代码
	return 返回值;
}

形参列表：可以有0个或多个，如果有多个形参，形参之间必须用','分隔，且不能给初始值
返回值类型：void --> 没有返回值类型 即方法中没有return数据

//示例
package com.test.define.method;

public class Method1 {
    public static void main(String[] args) {

//        定义一个方法 用于求和
        int res = sum(10, 20);
        System.out.println("res: " + res);

        int res2 = sum(50, 60);
        System.out.println("res2: " + res2);
    }

//方法和main方法同级
    public static int sum(int a, int b) { // public static为修饰符
        int c = a + b;
        return c;
    }
}

//输入结果：
res: 30
res2: 110

方法常见问题

在这里插入图片描述

在方法中引用类型的参数传递 在方法中改变引用类型的值后，主方法中的引用类型数据结果也会随之改变

package com.test.define.method;

public class Method3 {
    public static void main(String[] args) {
        int[] arr = {1, 4, 5, 9, 10};
        change(arr);
        System.out.println("main方法中" + arr[2]); //999

    }

    //方法调用change
    public static void change(int[] arr) {
        System.out.println("方法内arr[2]改变前" + arr[2]); //5
        arr[2] = 999;
        System.out.println("方法内arr[2]改变后" + arr[2]);//999
    }
}

//打印结果
方法内arr[2]改变前5
方法内arr[2]改变后999
main方法中999

方法重载

在这里插入图片描述

package com.test.define.method;

public class Method4 {
    public static void main(String[] args) {
        method1();
        method1(123);
    }

    // 方法重载 可以根据形参进行区分调用的哪个方法
    public static void method1() {
        System.out.println("方法一");
    }

    public static void method1(int number) {
        System.out.println("方法二" + number);
    }

}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值