Java狂神说笔记

最新推荐文章于 2024-08-29 18:44:48 发布

惜曦Xixi

最新推荐文章于 2024-08-29 18:44:48 发布

阅读量630

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Fairy_limeng/article/details/120386858

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

这是一份关于Java的零基础学习笔记，涵盖了Java基本语法，包括注释、标识符、数据类型、变量、常量、运算符、包机制、JavaDoc，流程控制如Scanner、循环结构和方法等内容，详细解析了Java编程的基础概念和实践操作。

摘要由CSDN通过智能技术生成

B 狂神说Java零基础学习视频总结

Java基本语法

1、注释

单行注释

//单行注释

多行注释

/*
多行注释
多行注释
*/

JavaDoc文档注释

/**
  *@Description Helloworld
  *@Author 惜曦Xixi
  */

注意：注释不会被执行

2、标识符

关键字

不能使用关键字来作为变量名或方法名
请添加图片描述

注意点

首字符可以是字母（A-Z或a-z）、美元符（$）或者下划线（_）
首字符后可以使用任何字符的组合
当然，除了~、！、@、#、%、^、&、*这些特殊符号
大小写敏感

合法标识符：age、$salary、_value、__1_value
非合法标识符：123abc、-salary、#abc

个人观点：直接都用单词（字母）就好啦！

建议使用英语命名，尽量不要用中文或拼音

3、数据类型

强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义再使用，如果要改变其数据类型，则需要强制转换。
例如：Java、.net 、Python、C++
弱类型语言
变量被定义类型之后，可以根据环境变化自动进行转换，不需要经过显性强制转换。
例如：vb 、PHP、javascript

Java的数据类型

基本数据类型

Long类型要在数字后面加L
例：long n1 = 21L;
float类型要在数字后面加F
例：float n2 = 21.1F;
引用数据类型
- 类
- 接口
- 数组

String是类，不是关键字

知识拓展

字节

位（bit）: 计算机内部数据存储的最小单位，11001100是一个八位二进制数；boolean类型只占一位，其值只有true和false两个
字节（byte）: 是计算机中数据处理的基本单位，习惯上用B来表示
- 1B(byte,字节) = 8bit(位)
字符：是指计算机中使用的字母、数字、字和符号

1G = 1024M
1M = 1024KB
1KB = 1024B
1B = 8b

进制的表示：

二进制：0b10 = 2
八进制：010 = 8
十进制：10
十六进制：0x10 = 16
- 0 - 9, A - F

浮点数：

浮点数能表现的字长是有限的
离散
舍入误差
接近但不等于

计算机在处理浮点数的时候是有误差的，最好避免完全使用浮点数进行比较，可使用BigDecinal类（数学工具类）进行比较

字符：强制转换

char c = 'a';
System.out.println(c);
System.out.println((int)c);

运行结果：
a
97

所有的字符本质还是数字

编码 Unicode表[十六进制]：(0 - 65536)
表示方式：\U0000 \UFFFF
例：a(97) -> \u0061

转义字符：
\t：制表符
\n：换行

String a = new String("Xixi");
String b = new String("Xixi");
System.out.println(a==b);
//二者地址不同

String c = "Xixi";
String d = "Xixi";
System.out.println(c==d);
//比较的是值

运行结果：
false
true

4、变量

每个变量都要声明其类型，可以是基本类型或引用类型
变量名必须是合法的标识符
以分号（英文状态）结束

变量作用域

类变量 static
实例变量
- 方法的外面，类的里面
- 从属于对象
局部变量
- 必须声明并初始化值

public class Demo1 {

    //类变量 static
    static double salary = 4000;

    //实例变量：从属于对象
    String name;
    int age;

    public static void main(String[] args) {
        //局部变量：必须声明并初始化值
        int a = 10;
        System.out.println(a);
        
        Demo1 demo1 = new Demo1();
        System.out.println(demo1.name);
        System.out.println(demo1.age);
        System.out.println(salary);
    }

实例变量若不进行初始化，直接输出的是其默认值

默认值：

整数：0
浮点数：0.0
布尔值：false
除了基本类型，其他都是null

5、常量

final 常量值 = 值;

//两个都是修饰符，不存在先后顺序

static final double PI = 3.14;
final static double PI = 3.14;

常量名一般使用大写字符

####变量的命名规范

所有的变量、方法、类名：见名知意
类成员变量、局部变量：首字母小写和驼峰原则：monthSalary
方法名：首字母小写和驼峰原则：run(),runRun()
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan

6、运算符

重点->

算数运算符：+，-，*，/，%，++，–

int a = 10;
int b = 20;

System.out.println(a/b); //运行结果：0
System.out.println(a/(double)b);//运行结果：0.5

long c = 12345678987L;
int d = 123;
short e = 10;
byte f = 8;

System.out.println(c+d+e+f);//输出结果：12345679128，Long类型
System.out.println(d+e+f);//输出结果：141，Int类型
System.out.println(e+f);//输出结果：18，Int类型
//强制转换
System.out.println((double)e+f);//输出结果：18.0，Double类型

//求模运算，取余
int g = 22;
System.out.println(g%a);//输出结果：2

int a = 3;
int b = a++;//先赋值，再自增
int c = ++a;//先自增，再赋值

System.out.println(a);//输出结果：5
System.out.println(b);//输出结果：3
System.out.println(c);//输出结果：5

赋值运算符：=
关系运算符：>，<，>=，<=，==，!=，instanceof
- 关系运算符结果：true/false（布尔值）
逻辑运算符：&&，||，！
- &&：与（and）
- ||：或（or）
- !：非（取反）

短路运算：

int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);//运算结果为：false
System.out.println(c);//运算结果为：5

//说明&&后面的部分并未执行，属于短路运算

了解->

位运算符：&，|，^，~，>>，<<，>>>
- 位运算（二进制：效率高）：
  - ^：异或（若相同则为0，不同则为1）
  - ~：非

A = 0011 1100
B = 0000 1101

A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010

	/*
	<<	*2
	>>	/2
	2 * 8 = 16 = 2*2*2*2
	*/
System.out.println(2<<3);//输出结果为：16

条件运算符：?，:

// x ? y : z
//如果x == true，则结果为y，否则为z

int score = 90;
String type = score < 60?"不及格":"及格";
// if语句
System.out.println(type); //输出结果为：及格

优先级用()

扩展运算符：+=，-=，*=，/=

int a = 10;
int b = 20;

a+=b; //a = a + b

System.out.println(a);//输出结果为：30

拓展

字符运算符

int a = 10;
int b = 20;

System.out.println("" + a + b); //输出结果为：1020
System.out.println(a + b + ""); //输出结果为：30

总结：当运算时出现字符类型时，若字符串在前面，后面的部分会以字符串的形式拼接；若字符串在后面，前面部分会运算后再拼接

幂运算

//幂运算 2^3 用Math.pow()
System.out.println(Math.pow(2,3));//输出结果：8.0

7、包机制

一般利用公司域名倒置作为包名，例如：com.xixi.xxx
为了使用某个包的成员，需要用import语句进行导包

8、JavaDoc

javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

Java流程控制

1、Scanner对象

通过Scanner类来获取用户的输入

基本语法：

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.nextLine();

System.out.println(n);
System.out.println(s);
sc.close();

IO流：输入输出

通过Scanner类的next()与nextLine()方法获取输入的字符，在读取之前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入数据。

两个方法

next
- 一定要读取到有效字符后才能结束输入
- 有效字符前的空白，会被过滤掉
- 有效字符后的空白会被当成分隔符或者结束符
- next()不能得到带空格的字符串
nextLIne()：
- 以Enter为结束符，返回的是输入回车之前的所有字符
- 可以获得空白

Scanner sc = new Scanner(System.in);

if(sc.hasNext()){
	String str = sc.next();
	System.out.println("输出的内容为："+str);
}

if(sc.hasNextLine()){
	String str = sc.nextLine();
	System.out.println("输出的内容为："+str);
}

sc.close();

2、顺序结构

从上到下顺序执行，是一种基本算法结构

3、选择结构

if单选择结构

Scanner sc = new Scanner(System.in);
String s = sc,nextLine();

if(s.equals("Hello")) {
	System.out.println(s);
}

sc.close();

判断字符串是否相等，用equals方法！！！

if双选择结构

Scanner sc = new Scanner(System.in);
int score = sc.nextInt();

if(score>=60) {
	System.out.println("及格");
} else {
	System.out.println("不及格");
}

sc.close();

if多选择结构

		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的成绩：");
		int score = sc.nextInt();

		if(score>100 || score<0) {
			System.out.println("你输入的成绩有误！");
		}else if(score>=90){
			System.out.println("A");
		}else if(score>=80){
			System.out.println("B");
		}else if(score>=70){
			System.out.println("C");
		}else if(score>=60){
			System.out.println("D");
		}else {
			System.out.println("E");
		}

		sc.close();

嵌套的if结构

Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
String s = sc.nextLine();

if(score>60) {
	if(s.equals(" Xixi")) {
		System.out.println("惜曦没有挂科！");
	}
}
sc.close();
// 输入：90 Xixi
// 输出：惜曦没有挂科！

switch多选择结构

switch语句中的变量类型可以是：
- byte、short、int、char、String

		Scanner sc = new Scanner(System.in);
		String day = sc.nextLine();
		
		switch(day) {
		case "Monday":
			System.out.println("星期一");
			break;
		case "Tuesday":
			System.out.println("星期二");
			break;
		case "Wednesday":
			System.out.println("星期三");
			break;
		case "Thursday":
			System.out.println("星期四");
			break;
		case "Friday":
			System.out.println("星期五");
			break;
		case "Saturday":
			System.out.println("星期六");
			break;
		case "Sunday":
			System.out.println("星期日");
			break;
		default:
			System.out.println("你输入的不是星期数");
		}
		sc.close();

若不加break;则会出现case穿透的现象

Scanner sc = new Scanner(System.in);
String name = sc.nextLine();
		
switch(name) {
case "Rolin":
	System.out.println("氯磷");
case "Xixi":
	System.out.println("惜曦");
default:
	System.out.println("磷曦");
}

sc.close();

/*
输入：
Xixi
输出：
惜曦
磷曦
*/

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int i = 0;
int sum = 0;
		
while(i<=n) {
	sum = sum + i;
	i++;
}
		
System.out.println(sum);

sc.close();

/*
输入：
10
输出：
55
*/

4、循环结构

while循环

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
		
while(n<5) {
		System.out.println(n++);
}

sc.close();

/*
输入：
2
输出：
2
3
4
*/

do…while循环

do…while循环与while循环相似，不同的是，do…while循环至少会执行一次
while先判断后执行，do…while先执行后判断

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int i = 0;
int sum = 0;
		
do{
	sum = sum + i;
	i++;
}while(i<=n);
		
System.out.println(sum);

sc.close();

/*
输入：
10
输出：
55
*/

for循环

结构：

for(初始化;布尔表达式;更新) {
	//代码语句
	}

例：

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = 0;
		
for(int i=0;i<=n;i++) {
	sum = sum + i;
}
System.out.println(sum);
		
sc.close();

//输入：10
//输出：55

练习

1、计算0-100之间的偶数和

//仅供参考
int n = 100;
int sum = 0;
		
for(int i=0;i<=n;i++) {
	if(i%2==0) {
		sum+=i;
	}
}
System.out.println(sum);

2、用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

//仅供参考
//while循环
int i=1;
int m=0;
		
while(i<=1000) {
	if(i%5==0) {
		m++;
		if(m%3!=0) {
			System.out.print(i+" ");
		}else {
			System.out.println(i);
		}
	}
	i++;
}
//for循环
int m = 0;
for(int i=1;i<=1000;i++) {
	if(i%5==0) {
		m++;
		if(m%3!=0) {
			System.out.print(i+" ");
		}else {
			System.out.println(i);
		}
	}
}

3、打印九九乘法表

//仅供参考
for(int i=1;i<=9;i++) {
	for(int j=1;j<=i;j++) {
			System.out.print(j+"*"+i+"="+ (i*j) + " ");
	}
	System.out.println("");
}

增强for循环

主要用于数组或集合

int[] n = {10,20,30,40,50};//定义数组
		
//（简化）遍历数组中的元素
//把n的值直接赋给x
for(int x:n) {
	System.out.println(x);
}

//第二种方式
for(int i=0; i<5; i++) {
	System.out.println(n[i]);
}

break continue goto

break:用于强行退出循环，不执行循环中剩余的语句
continue:用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着执行下一次是否执行循环的判断
goto:未正式使用，但在break和continue中可以看到goto的影子（带标签）【不建议使用】

int i=0;
while(i<20) {
	i++;
	System.out.println(i);
	if(i==10) {
		break;
	}
}

int i=0;
while(i<20) {
	i++;
	if(i%10==0) {
		System.out.println();
		continue;
	}
	System.out.print(i + " ");
}

//打印101-150之间的质数
outer:for(int i=101; i<150; i++) {
	for(int j=2; j<i/2; j++) {
		if(i%j==0){
		continue outer;
		}
	}
	System.out.print(i+" ");
}

练习打印三角形

for(int i=1; i<=5; i++) {
	for(int j=5; j>=i; j--) {
		System.out.print(" ");
	}
	for(int j=1; j<=i; j++) {
		System.out.print("*");
	}
	for(int j=1; j<i; j++) {
		System.out.print("*");
	}
	System.out.println();
}

/*
运行结果：
     *
    ***
   *****
  *******
 *********
 */

Java方法

1、何谓方法

Java方法是语句的集合，它们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
- 一个方法只能完成一个功能
- 命名方法：首字母小写+驼峰原则例：getSum

public static void main(String[] args) {
	int sum = add(1,2);
	System.out.println(sum);
}
	
public static int add(int a,int b) {
	return a+b;
}

2、方法的定义和调用

方法的定义

类似于其它语言的函数

方法包含一个方法头和一个方法体
- 修饰符：告诉编译器如何调用该方法，定义了该方法的访问类型可选
- 返回值类型：方法可能会返回值，returnValueType是方法的返回值的数据类型。没有返回值的话用关键字void
- 方法名：方法的名称，方法名和参数表共同构成方法签名
- 参数类型：方法被调用时，传递值给参数
  - 形参：在方法被调用时用于接受外界输入的数据
  - 实参：调用方法时实际传给方法的数据
- 方法体：方法体包含具体的语句，定义该方法的功能

格式：

修饰符 返回值类型 方法名(参数类型 参数名) {
	方法体
	return 返回值;
}

方法调用

调用方法：对象名.方法名(实参列表)

Java两种调用方式

当方法返回一个值时，方法调用通常被当成一个值

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句

public static void main(String[] args) {
    method();
}

public static void method() {
   System.out.println("Xixi");  
}

拓展

值传递（Java）和引用传递
Java只有值传递！！！

3、方法的重载

重载：在一个类中，相同的函数名，形参不同
规则：

方法名必须相同
参数列表必须不同（个数、类型不同、参数排列不同等）
方法的返回类型可以相同也可以不同
返回类型不同不足以成为方法重载

拓展

命令行传参

//编译
src\com\Xixi\method>javac Demo01.java
//返回上一级（返回至src）
src\com\Xixi\method>cd ..
//直接传参
src>java com.Xixi.method.Demo01 Xixi

可变参数

在方法声明中，在指定参数类型后加一个省略号（…）不定项
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

	public static void main(String[] args) {
		printMax(123);
		//printMax(123,465);输出结果为The max value is 465.0
	}
	
	public static void printMax( double... numbers) {
		if(numbers.length == 0) {
			System.out.println("No argument passed");
			return;
		}
		
		double result = numbers[0];
		
		for(int i=1; i<numbers.length; i++) {
			if(numbers[i]>result) {
				result = numbers[i];
			}
		}
		System.out.println("The max value is " + result);
	}

//输出结果：The max value is 123.0

	public static void main(String[] args) {
		VariableParameters vp = new VariableParameters();
		vp.test(12,23);
	}
	
	public void test(int... i) {
		System.out.println(i[1]);
	}

思考：为什么要new？

由于main方法的修饰符是static，属于静态的，而test方法是动态的，所以不能直接使用
静态的只能引用静态的，动态的只能引用动态的

那为什么new了一下就可以了用了呢？

new了一下，相当于把这个类创建成对象
对象是动态的，所以main方法就可以通过对象调用test方法了

个人观点：在test方法里面加个修饰符static，不就好了？emmmm

递归

自己调用自己！

递归结构包括两部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法。
  基数比较大的话不建议使用递归方法

	public static void main(String[] args) {
		
		System.out.println(f(4));
		System.out.println(f(5));

	}
	
	//阶乘是如何实现的？
	//4!	4*3*2*1
	//5!	5*4*3*2*1
	
	public static int f(int n) {
		if(n==1) {
			return 1;
		}else {
			return n*f(n-1);//自己调用自己！！！
		}
	}

练习：简单计算器

没有界面那种哈哈哈哈哈哈

		while(true) {
			System.out.println("请输入计算类型(+,-,*,/),或者输入q推出计算器");
			Scanner sc1 = new Scanner(System.in);
			String o = sc1.next();
			
			if(o.equals("q")) {
				System.out.println("已退出计算器");
				break;
			}else {
				switch(o) {
					case "+":
						System.out.println("请输入要计算的两个数，以回车分割：");
						Scanner sc2 = new Scanner(System.in);
						double a = sc2.nextDouble();
						double b = sc2.nextDouble();
						System.out.println(a+b);
					case "-":
						System.out.println("请输入要计算的两个数，以回车分割：");
						Scanner sc3 = new Scanner(System.in);
						double c = sc3.nextDouble();
						double d = sc3.nextDouble();
						System.out.println(c-d);
					case "*":
						System.out.println("请输入要计算的两个数，以回车分割：");
						Scanner sc4 = new Scanner(System.in);
						double e = sc4.nextDouble();
						double f = sc4.nextDouble();
						System.out.println(e*f);
					case "/":
						System.out.println("请输入要计算的两个数，以回车分割：");
						Scanner sc5 = new Scanner(System.in);
						double g = sc5.nextDouble();
						double h = sc5.nextDouble();
						System.out.println(g/h);
				}
			}
			sc1.close();
		}

数组

1、数组概述

相同类型数据的有序集合
按照一定的先后次序排列组合而成
每一个数组称作一个数组元素，每个数组元素可以通过一个下标来访问

2、数组声明创建

首先，必须声明数组变量，才能在程序中使用数组
Java语言使用new操作符来创建数组
数组的元素是通过索引访问的，数组索引从0开始
获取数组的长度：数组名称.length
语法：

//第一种
int[] nums;//声明一个数组
nums = new int[10];//这里面可以存放10个int类型的数字
//第二种
int[] nums = new int[10];

//给数组赋值
int[] nums = new int[10];

for(int i=0; i<nums.length; i++) {
	nums[i] = i+1;
	System.out.print(nums[i]+" ");
}
/*
输出结果：
1 2 3 4 5 6 7 8 9 10 
*/

3、内存分析及三种初始化

内存分析

请添加图片描述

三种初始化

静态初始化
- 一旦定义，空间大小则不可改变

int[] a={1,2,3};
Student[] student = {new Student(1,1),new Student(2,2)};

动态初始化

int[] a = new int[2];
a[0]=1;
a[1]=2;

数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

数组边界

下标的合法区间：[0, length-1]，如果越界就会报错；
java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常

4、数组使用

5、多维数组

6、Arrays类

7、稀疏数组

惜曦Xixi

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java狂神说笔记

Java基本语法B 狂神说Java零基础学习视频 p21-24 总结目录Java基本语法1、注释2、标识符关键字注意点3、数据类型Java的数据类型知识拓展字节进制的表示：浮点数：字符：强制转换1、注释单行注释//单行注释多行注释/*多行注释多行注释*/JavaDoc文档注释/** *@Desciption Helloworld *@Author 惜曦Xixi */注意：注释不会被执行2、标识符关键字不能使用关键字来作为变量名或方法名注
复制链接

扫一扫