Java的注释有3种,分别是单行注释、多行注释、文档注释,格式如下
//单行注释
/*多行注释*/
/**文档注释*/
java是一种强类型语言.这就意味着必须为每一个变量声明一种数据类型,在java中一共有8种数据类型,分别如下:
类型 | 存储需求 | 取值范围 |
---|---|---|
byte | 1字节 | -128~127 |
short | 2字节 | -32 768~32 767 |
int | 4字节 | -2 147 483 648~214 748 647 |
long | 8字节 | -9 223 372 036 854 775 808~9 223 372 036 854 775 807 |
在java中,整型的范围与运行java代码的机器无关,这就解决了软件从一个平台移植到另一个 平台或者同一个平台不同操作系统的问题,相反C程序会针对不同的处理器选择最为高效的整型,这样会造成一个在32位处理器上运行很好的C程序在16位操作系统上运行时却发生溢出.由于java程序必须保证在每个机器上的运行结果相同,所以各种数据类型的取值范围必须固定.
浮点类型数据用于表示有小数部分的数值,在java中有2种浮点类型,分别如下:
类型 | 存储需求 | 取值范围 |
---|---|---|
float | 4字节 | 1.4E-45~3.4028235E38 (E是一个16进制数位) |
double | 8字节 | 4.9E-324~1.7976931348623157E308 |
char类型的值需要用单引号括起来,例如’A’是编码值为65的字符常量,而"A"是一个字符串.
类型 | 存储需求 | 取值范围 |
---|---|---|
char | 2字节 | 0~65535 |
boolean类型一般用来判定逻辑条件,注意:整型值与boolean值之间不能进行相互转换.
类型 | 存储需求 | 取值范围 |
---|---|---|
boolean | 1字节 | true / false |
java 字符串转换为Boolean值可以通过Boolean.valueof来实现字符串到boolean值的转换:只有字符串为true 且忽略大小写比如:True/TRue/TRUE等返回布尔值true,其他都返回false.
Boolean b1 = Boolean.valueOf("true");
System.out.println(b1);// true
Boolean hh = Boolean.valueOf("hh");
System.out.println(hh);// false
Boolean aFalse = Boolean.valueOf("false");
System.out.println(aFalse);//false
Boolean aTrue = Boolean.valueOf("True");
System.out.println(aTrue);//true
Boolean aBoolean = Boolean.valueOf(null);
System.out.println(aBoolean);// false
在java中,有多种类型常量,例如:
//字符串常量: 双引号括起来的内容
System.out.println("hello");
//字符常量: 单引号括起来的的一个字符
System.out.println('a'); //小写字符
System.out.println('A'); //大写字符
System.out.println('1'); //数字字符
System.out.println('中'); //文中字符
System.out.println('+'); //符号字符
//整数常量:直接写的数字
System.out.println(100);
//浮点常量:只写的小数
System.out.println(3.14);
//布尔常量:true或者false
System.out.println(true);
System.out.println(false);
//空常量:null(该常量不能打印输出)
还有一种使用关键字final指示常量,一般希望某个常量可以在一个类的多个方法中使用,通常称这些为类常量,一般使用 static final 设置一个类常量,需要注意:类常量一般要放在main方法外,如果使用public 修饰的话,多个类都可以使用这个类常量.
变量从字面上理解就是可以发生改变的量。变量的本质其实是内存中的一小片内存空间,用来存储一个数据,而这个空间的的数据可以在一定范围内发生改变(这里所说的一定范围,就是数据类型)
格式
//单独定义变量
数据类型 变量名;
//定义变量并赋值
数据类型 变量名=初始值;
声明变量并使用
public static VariableDemo1{
public static void main(String[] args){
//单独声明变量
int a;
a=10; //给变量a赋值为10
System.out.println("a的值:"+a);
a=20; //修改变量a的值为20
System.out.println("a的值:"+a);
//定义变量并赋值
int b=10;
System.out.println("b的值:"+b);
b=20; //修改变量b的值为20
System.out.println("b的值:"+b);
}
}
变量的初始值:
变量没有赋值,不能够直接使用
public class VariableDemo2{
public static void main(String[] args){
//指定定义了变量,没有赋值
int a;
//没有赋值的变量,不能直接使用
System.out.println(a); //编译报错
}
}
变量的作用域:
作用域指的是变量所在的{}范围内,一个变量定义在哪个{}范围内,就只能在哪个范围内有效。看如下代码
public class VariableDemo3{
public static void main(String[] args){
//变量a的作用域为 第3行~13行
int a=10;
{
//变量b的作用域为 第5行~9行
int b=20;
System.out.println(b); //正确
}
System.out.println(a); //正确
//这里超过了变量b定义的{}范围
System.out.println(b); //编译报错
}
}
同一行定义多个变量:
可以在一行定义多个相同类型的变量,代码如下:
public class VariableDemo4{
public static void main(String[] args){
//a和b都是int类型,值分别为3和4
int a=3,b=4;
System.out.println(a);
System.out.println(b);
}
数据类型转换指的是同一个数据可以用不同的数据类型存储。比如我们需要用一个变量来表示整数10,能用那些数据类型来存储呢?我们发现byte、short、int、long都能存储整数10。
当这个变量先用byte类型存,后来又用int类型存,我们就说这个变量发生了自动类型转换;
当这个变量先用int类型存,后来又用byte类型存,我们就说这个变量发生了强制类型转换
public class DateTypeCastDemo1{
public static void main(String[] args){
//把整数10赋值给byte类型的变量a
byte a=10;
//变量a从byte类型转为int类型
int b=a;
}
}
以上代码中数据10刚开始用byte类型存储,后来用int类型存储,像这种从小大到的转换叫做自动类型转换,它不会改变数据大小。
//强制类型转换格式
数据类型 变量名=(数据类型)被转换的数据;
public class DateTypeCastDemo1{
public static void main(String[] args){
//把整数127赋值给byte类型
int a=127;
//把int类型的变量a强制转换byte类型
byte b=(byte)a;
}
}
此处我们可以理解成小桶水倒进大桶里完全可以(自动类型转换),大桶水倒进小桶里,需要大桶舍弃一些水然后倒进小桶(强制类型转换).
运算符就是在程序中参与运算符的符号,下面是我们要学习的一些运算符.
我们先来学习算数运算符的 +(加) -(减) *(乘) /(除) 以及 %(取模).
运算符 | 含义 |
---|---|
+ | 加法运算、字符串拼接 |
- | 减法运算 |
* | 乘法运算 |
/ | 除法运算,整数相除只能得到整数 |
% | 取模(余数) |
用代码演示一下:
public class ArithmeticDemo1{
public static void main(String[] args){
System.out.println(5+3); //加法运算:8
System.out.println(5-3); //减法运算:2
System.out.println(5*3); //乘法运算:15
System.out.println(5/3); //除法运算:1
System.out.println(5%3); //取余运算:2
//需要注意的是整数相除只能得到整数
System.out.println(5/2); //2
//如果想得到小数必须有小数参与运算
System.out.println(5.0/2); //2.5
}
}
+符号不仅仅能做加法运算,它与字符和字符串参与运算还有其他功能。下面来看代码演示.
public class ArithmeticDemo2{
public static void main(String[] args){
//+符号与数值运算: 普通加法运算
System.out.println(3+4); //7
//+符号与字符运算: 先把字符转为int,再做加法运算
System.out.println('a'+1); //98
//+符号与字符串运算:字符串连接符
Sytem.out.println("hello"+5+5); //hello55
System.out.println(5+5+"hello"); //10hello
System.out.println("5+5="+10); //5+5=10
}
}
自增、自减两个特殊的运算符,它是自身原有数据上加1或者减1.
运算符 | 含义 |
---|---|
++ | 自增 |
– | 自减 |
++和–运算符的使用要两种情况来看,第一种是单独使用,第二种是混合使用。我们先来学习单独使用.
单独使用:
++和–放在操作数前面和后面,结果都是一样的,最终结果都会在原有数据上自增1或者自减1
public class ArithmeticDemo3{
public static void main(String[] args){
int a=3;
int b=4;
a++; //等价于 ++a
System.out.println(a); // 4
b--; //等价于 --bb
System.out.println(b); // 3
}
}
混合使用
++或者–可以放在操作数前面,也可以方法操作数后面。不管++或者–放在操作数后面还是前面,该自增1还是会自增1,该自减1还是会自减1,只是运算顺序有所不同
我们以++和赋值运算混合使用为例来做代码演示;–的用法和++类似,自己完成。
public class ArithmeticDemo4{
public static void main(String[] args){
int a=3;
//等价于a++; int b=a;
int b=++a;
System.out.println();//4
System.out.println(a);//4
int x=3;
//等价于int y=x; x++
int y=x++;
System.out.println(x);
System.out.println(y);
//常量不能做自增、自减运算
System.out.println(5++); //错误写法
}
}
总结一下:不管++(–)放在操作数的前面还是后面,最终都得+1或者-1,只不过运算顺序不一样
注意:常量不能做自增和自减运算
赋值运算符的用途是把右边的结果赋值给左边。分为基本的赋值运算和扩展的赋值运算符。
先来看一下基本的赋值运算符,我们直接用代码演示
运算符 | 含义 |
---|---|
= | 把右边的值赋值给左边 |
public class AssignDemo1{
public static void main(String[] args){
//把右边的整数10,赋值给左边的int变量a
int a=10;
}
}
接下来学一下扩展的赋值运算符,分别为+=、-=、*=、/=、%=,它们用于把左右两边运算的结果重新赋值给左边。下面看一下代码演示
运算符 | 含义 |
---|---|
+= | 左右两边相加的结果赋值给左边 |
-= | 左右两边相减的结果赋值给左边 |
*= | 左右两边相乘的结果赋值给左边 |
/= | 左右两边相除的结果赋值给左边 |
%= | 左右两边取余数的结果赋值给左边 |
public class AssignDemo2{
public static void main(String[] args){
int a=20;
//把a+10之结果再赋值给a,最终a=30
a+=10;
System.out.println(a); //30
int b=5;
//把b/2之结果再赋值给b,最终a=2
b/=2;
System.out.println(b); //2
int c=10;
//把y对4取余数的结果再赋值给y,最终,c=2
c%=4;
System.out.println(c); //2
//注意:扩展的赋值运算符,隐含的有一个强制类型转换
byte s=3;
s+=4;//等价于 s=(byte)(s+4);
System.out.println(s); //7
}
}
用来对两个数据做比较运算,最终结果只能是true或者false
运算符 | 含义 |
---|---|
">‘’ | 大于 |
‘’>=‘’ | 大于等于 |
< | 小于 |
<= | 小于等于 |
== | 判断相等 |
!= | 判断不相等 |
逻辑运算可以对多个boolean条件进行连接,最终结果也是true或者false
运算符 | 含义 |
---|---|
&(与) | 两个条件都满足结果才是true |
∣(或) | 有一个条件满足结果就是true |
!(非) | 对结果取反 |
&&(双与) | 两个条件都满足结果才是true,左边为false右边不运算 |
∣∣(双或) | 有一个条件满足结果就是true,左边为true右边不运算 |
int a=3;
int b=4;
int c=5;
//&(与): 左右两边都是true,结果才是true
System.println(a>b&bb|bb&&bb||b
格式:数据类型 变量名 = 关系表达式 ? 表达式1 : 表达式2;
执行流程:
首先判断关系表达式的结果是true还是false,
如果关系表达式是true,三元运算的结果就是表达式1,
如果关系表达式是false,三元运算的结果就是表达式2,
注意:三元运算的结果必须被使用,要么直接打印输出,要么使用变量存起来.
优先级 | 运算符 | 结合性 |
---|---|---|
1 | []、()(方法调用) | 从左向右 |
2 | !、+、-、~、++、– | 从右向左 |
3 | *、/、% | 从左向右 |
4 | +、- | 从左向右 |
5 | <<、>>、>>> | 从左向右 |
6 | <、<=、>、>=、instanceof | 从左向右 |
7 | ==、!= | 从左向右 |
8 | & | 从左向右 |
9 | ^ | 从左向右 |
10 | I | 从左向右 |
11 | && | 从左向右 |
12 | II | 从左向右 |
13 | ?: | 从右向左 |
14 | =、+=、-=、*=、/=、&=、I=、^=、~=、«=、»=、>>>= | 从右向左 |
字符串在实际开发中用到的特别多,接下来我们先学习字符串的两种创建方式,分别如下:
第一种:直接赋值
String s1="hello world";
创建的字符串s1对象,只会在常量池中。hello world属于字面量(常量),创建s1对象的时候,JVM会先去常量池中通过equals(key)方法,判断是否有相同的对象
如果有,则直接返回该对象在常量池中的引用;
如果没有,则会在常量池中创建一个新对象,再返回引用
第二种:使用new String()来创建字符串
String s2 = new String("你好");
此时有两种情况:
1.JVM首先会查找字符串池中是否存在值为"你好"的对象,如果存在,则直接去堆内存中创建一个"你好",并将堆内存中的“你好”对象的引用(内存地址)赋给变量s2.
2.JVM首先会查找字符串池中是否存在值为"你好"的对象,发现不存在,则在字符串池中创建一个“你好”的对象,在堆内存中也创建一个“你好”对象,并将
堆内存中的“你好”对象的引用(内存地址)赋给变量s2;
实例:
String s1 = new String("hello"); ①
String s2 = new String("hello");②
String s3 = "hello";③
String s4 = "hello";④
String s5 = "你好";⑤
String类的 subString 方法可以从一个较大的字符串中提取一个子串.例如:
String s1 = "hello";
String s2 = s1.subString(0,3); // 从hello的0位置开始复制到第3位,但不包含第3位.
System.out.println(s2); // 结果是hel
拼接即连接两个字符串,话不多说,直接上示例:
第一种情况:
String s1 = "hello,";
String s2 = "world";
String s3 = s1+s2;
System.out.println(s3); // "hello,world"
第二种情况:
如果一个字符串与一个非字符串的值进行拼接,那么后者会转换成字符串进行拼接.
int age = 10;
String s4 = "5+5=";
String s5 = s4+age;
System.out.println(s5); // "5+5=10"
String类的split()方法可根据给定的分隔符对字符串进行拆分。
String s1 = "你好,我好,大家好";
String [] split = s1.split(",");
for(int i=0 , i < split.length , i++ ){
System.out.println("索引" + i + "位置的元素为:"+ split[i]);
// "索引0位置的元素为:你好"
// "索引1位置的元素为:我好"
// "索引2位置的元素为:大家好"
}
String 类中contains( )方法可以判断字符串是否包含指定内容。
String s1 = "Java编程思想";
boolean a = s1.contains("Java");
System.out.println(a); // true
比较字符串对象的内容是否相同,就需要用equals()方法。并且进行比较的字符串不为null,内容相同返回true。
注意:比较时前者不允许为null,否则直接报错,后者可以为null。
String s1 = "abc";
String s2 = "abc";
String s3 = "bcd";
System.out.println(s1.equals(s2)); //true
System.out.println(s1.equals(s3)); //false
首先我们要学会使用基本的控制台实现输入输出.
- 1.导包,写在class类的上面
import java.util.Scanner;
- 2.创建Scanner对象
Scanner sc=new Scanner(System.in);
- 3.调用方法获取键盘录入数据
int num=sc.nextInt(); //读取整数
double num1 = sc.nextDouble(); //读取一个浮点数
System.out.print(); // 不换行打印
System.out.println(); // 换行打印
接下来我们要学习一个知识点叫做随机数,和键盘录入非常类似,我们来看一下。
产生随机数的步骤
//1.导包(可以先不写,由Idea自动导入)
import java.util.Random;
//2.创建随机数对象
Random r=new Random();
//3.获取键盘录入数据
int num=r.nextInt(10); //这里的10,表示随机数的范围是[0,10)
我们来做一个代码的演示
//1.导包
import java.util.Random;
public class Demo1{
public static void main(String[] args){
//2.创建Random对象
Random r=new Random();
//获取10个随机数
for(int i=1;i<=10;i++){
int num=r.nextInt(10);
System.out.println(num);
}
}
}
在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的,也就是说程序的流程对运行结果有直接的影响。在清楚每条语句的执行流程的前提下,才能通过控制语句的执行顺序来实现我们要完成的功能。
if是如果的意思,用来对条件进行判断,根据条件判断的结果是否成立,选择性的执行不同的语句体。
先来看一下单if语句的格式和执行流程
//如果条件成立,执行下面的语句体;否则不执行
if(条件判断){
语句体;
}
键盘录入一个整数,判断这个整数是否为偶数,如果这个数是偶数,就是输出”xx是偶数“(xx表示你输入的数)
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数:");
int num=sc.nextInt();
//判断num是否为偶数
if(num%2==0){
System.out.println(num+"是偶数");
}
上面代码只能判断输入的数是偶数的情况,输出这个数是偶数;如果输入的数不是偶数,将什么也做不了。所以就有了下面的if…else语句
还是先来看一下,if...else语句的格式和执行流程
//如果条件成立执行,语句体1;否则执行语句体2;
if(条件){
语句体1;
}else{
语句体2;
}
键盘录入一个整数,判断这个整数是否为偶数,如果这个数是偶数,就是输出”xx是偶数“;否则输出”xx是奇数“(xx表示你输入的数)
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数:");
int num=sc.nextInt();
//判断num是否为偶数
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
如果我们需要对两种以上的情况进行判断,就可以用if…else if语句.
if(条件1){ //如果条件1成立,执行语句体1
语句体1;
}else if(条件2){ //如果条件2成立,执行语句体2
语句体2;
}else{ //如果以上条件都不成立,执行最后的else
语句体n+1;
}
在使用if语句时,注意下面几个问题:
1. if后面()中的条件判断语句必须是boolean类型.
2. 如果是多个条件的情况,只会执行第一个条件为true的语句体;后面的条件就不再执行.
3. 如果{}中的语句体只有1条语句,{}可以省略
switch语句用于在几个固定的值之间进行选择,如一个星期有7天,一年有12个月等等。废话少说,我们直接用一个案例来学习switch语句。根据键盘录入的整数,输出对应的星期。
Scanner sc=new Scanner(System.in);
int week=sc.nextInt();
//假设键盘录入的是5,下面的case 5与之匹配,就执行该处的语句体。
//遇到break就结束,如果没有遇到break会穿透(你可以尝试删掉break试一下)
switch(week){
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
}
switch语句有下面的几个注意事项
switch小括号中的变量,类型只能是下面几种:
for这个单词没有特殊含义,它仅仅只表示接下来的代码是循环语句,有自己的执行流程。
/*
执行流程:
1.先执行初始化语句;
2.再执行条件判断语句;
如果条件为true,就执行循环语句体;
如果条件为false,就跳出循环,执行循环之后的代码
3.条件控制语句
4.回到2步骤继续执行
*/
for(初始化语句;条件判断语句;条件控制语句){
循环语句体;
}
注意: 在开发中可能要遇到两层for循环,但是在条件成立时就要跳出两层for循环,而continue只是跳出本次循环,执行下次循环,还有break是跳出本层循环,并不能满足需求,所以我们需要借助break的标记,从而实现跳出两层for循环
flag: //借助标记跳出两层for循环
for(初始化语句;条件判断语句;条件控制语句){
for(初始化语句;条件判断语句;条件控制语句){
if(条件){
循环语句体;
break flag;
}
}
}
接下来学习另外一种循环语句,叫做while循环,while循环的执行流程其实和for循环是一模一样的,只是格式不一样。在实际开发中根据需求来进行选择.
我们还是先学习一下while循环的格式和执行流程
初始化语句;
while(条件判断语句){
循环语句体;
条件控制语句;
}
我们通过一个简单的案例,来学习一下它的执行流程。打印输出5个"helloworld"
int i=1;
while(i<=5){
System.out.println("helloworld");
i++;
}
/*
执行流程分析:
1) 开始i=1;
2) 判断i<=5是否成立
如果条件成立,执行大括号中的代码 打印输出一个"helloworld"
如果不成立,while循环结束。
3) 执行i++,i变成2
4) 继续回到2步骤执行
*/
还是通过一个简单得案例来演示,打印输出10个"helloworld".
int i=1;
do{
System.out.println("helloworld");
i++;
}while(i<=10);
do...while循环有一个特点,就是不管条件是否成立,循环语句体先执行一次再说。
数组是用来存储多个数据的容器,有下面几个特点。
1.元素类型是一致的.
2.长度是不可变的.
//格式1:数据类型[] 数组名 = new 数据类型[长度];
int[] arrayA=new int[3];
//格式2:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素....};
int[] arrayB=new int[]{10,20,30};
//格式3:数据类型[] 数组名 = {元素1,元素2,元素....};
int[] arrayC={10,20,30};
在数组中每一个元素都有一个索引与之对应,这个索引其实就是一个从0开始的整数
int[] array={8,7,4,6,9,10,12};
System.out.pritnln(array); //地址值
System.out.println(array[0]); //8
System.out.println(array[4]); //9
System.out.println(array[6]); //12
Java把内存分为栈、堆、方法区主要的三个区域
栈:存储局部变量(定义在方法中的变量)
堆:存储new出来的数据(数组就是new出来的)
方法区:存储字节码相关信息(编译后生成的class文件)
遍历就是把数组中的元素一个一个的获取出来
int[] array={10,20,30,40};
//array.length: 数组的长度
for(int i=0;i
/*
1.定义一个求和变量sum
2.遍历所有需要求和的数据
3.把需要求和的数据和sum累加
*/
int[] array={10,20,30,40};
int sum=0;
for(int i=0;i
/*
打擂台的思路:
1.把数组中0索引元素假设为最大值max(有一个人擂台)
2.遍历其他元素和max进行比较(其他人和擂主比武)
如果其他元素>max,就把其他元素赋值给max(擂主换人)
3.循环结束之后,最终max就是最大值(最终的擂主)
*/
int[] array={8,20,7,29};
//把数组中0索引元素假设为最大值max(有一个人擂台)
int max=array[0];
//遍历其他元素和max进行比较(其他人和擂主比武)
for(int i=1;jmax,就把其他元素赋值给max(擂主换人)
if(array[i]>max){
max=array[i];
}
}
System.out.println("数组中元素的最大值为:"+max);
到此,java基础语法已经学习完啦,如有问题评论或者私信博主都可以哦,最后大家一起加油,成为你心中最想成为的那个"猿".