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:数组下标越界异常