java基础笔记
文章目录
1、运算符
1.1常见的数学运算符
+ - * / % ......
+
作用：
- 加法运算
- 拼接字符串
/*
+运算符
*/
public class Demo1 {
public static void main(String[] args) {
System.out.println(1+1);
/*
拼接字符串
1.将多个字符串的值 拼接成一个字符串
2.字符串与其他类型的值也可以拼接成一个字符串 规律：+的左边或者右边，只要有一边是字符串，则一定做拼接字符串处理
*/
String s1 = "Hello ";
String s2 = "Wrold ";
System.out.println(s1 + s2);
System.out.println("hello" + 3.14);
System.out.println(5 + 6 + "," + 6 + 5);
//11,65
}
}
%
取余
10%3 结果就是 1
public class Demo2 {
public static void main(String[] args) {
System.out.println(10%3);//1
System.out.println(3%10);//3
System.out.println(-4%10);//-4
System.out.println(-10%4);//-2
}
}
练习
声明整型变量，并赋值为5位数
取出该数的每一位的值
public class Demo3 {
public static void main(String[] args) {
int i = 56757;
int ge = i % 10;//取出个位数
int shi = i / 10 % 10;// 取出十位数
int bai = i / 100 % 10;// 取出百位数
int qian = i / 1000 % 10;// 取出千位数
int wan = i / 10000;// 取出万位数
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);
System.out.println(qian);
System.out.println(wan);
}
}
2、数学运算中的结果值的类型
public class Demo {
public static void main(String[] args) {
//在数学运算中，结果值的数据类型与运算中的最大类型一致
/*
结果值应该是int类型 真实结果是2.5 但是结果要处理为int
相当于将2.5转换为int类型 就是将小数位直接砍掉
*/
System.out.println(5/2);//2
//结果值应该是double类型
System.out.println(5/2.0);//2.5
++与–
++：自增符号
–：自减符号
++符号的基本效果：
整型变量++; 或者 ++整型变量;
效果：将该变量的本身的值+1
–符号的基本效果：
整型变量--; 或者 --整型变量;
效果：将该变量的本身的值-1
注意：在使用自增或自减符号时，变量一定要有值
public class Demo4 {
public static void main(String[] args) {
int i = 5;
i++;//将变量i的值+1
System.out.println(i);//6
++i;//将变量i的值+1
System.out.println(i);//7
int j = 6;
j--;//将变量j的值-1
System.out.println(j);
--j;//将变量j的值-1
System.out.println(j);
}
}
自增表达式本身的值
/*
a++:先赋值，再自增
++a:先自增，再赋值
赋值：将变量的值赋值给表达式复合运算符 基本使用
自增：将变量本身的值+1
*/
public class Demo5 {
public static void main(String[] args) {
int i = 5;
int j = 5;
/*
为什么i++的值为5
因为i++的效果是
1.将i的值赋值给 i++,所以i++的值就是i的值5
2.将i的值+1 i的值变为6
*/
System.out.println(i++);//5
System.out.println(i);//6
/*
为什么++j的值为6
因为++j的效果是
1.将j的值+1 变为6
2.将j的值赋值给++j 所以++j的值为6
*/
System.out.println(++j);//6
System.out.println(j);//6
int a = 5;
System.out.println(a++ + ++a);//12
int k = 6;//7 6
int v = 7;//6 7
System.out.println(k++ - --v + k-- - ++v);//0
// 6 6 7 7
}
}
3、复合运算符
a += 值; 效果： a = a + 值
a -= 值; 效果： a = a - 值
a *= 值; 效果： a = a * 值
....
基本使用
public class Demo6 {
public static void main(String[] args) {
int i = 5;
i += 5;//效果是 i = i + 5
System.out.println(i);//10
i -= 6;//效果是 i = i - 6
System.out.println(i);//4
}
}
自动进行类型转换
public class Demo7 {
public static void main(String[] args) {
byte b = 5; // b = b + 3;//会出错 因为右边的结果值是int类型所以需要强转
b = (byte)(b + 3);
System.out.println(b);
byte b2 = 5;
//b2 += 3 效果： b2 = b2 + 3. 但是我们并没有进行强转，因为复合运算符会自动的帮我们转换
b2 += 3;
System.out.println(b2);
}
}
小结 复合运算符的好处:
- 代码更简洁
- 如果需要类型转换，则复合运算符会自动的进行转换
赋值符号=
变量 = 值;
效果:java一定是先获取都右边的值，再将值赋值给左边的变量
练习
1、
int a = 5;
a = a++;
System.out.println(a);
2、
声明两个同类型的变量，交换这两个变量的值
public class Practise2 {
public static void main(String[] args) {
/*
声明两个同类型的变量，交换这两个变量的值
*/
int a = 5;
int b = 6;
/*
这个写法不能达到交换的效果
因为a = b 执行时，a变量的值因为被覆盖所以丢失
*/
// a = b;
// b = a;
// System.out.println(a);
// System.out.println(b);
/*
如果要替换两个变量的值
一定要避免某个变量的值丢失
解决：在某个变量的值被覆盖之前 全复制一份作为备份
*/
int c = a;
a = b;
b = c;
System.out.println(a);
System.out.println(b);
/*
要求不创建第三个变量达到替换的效果
实际开发中，不建议使用这个写法
因为可读性太差了
但是考试可能会遇到，所以要会写
*/
int i = 5;
int j = 6;
i = i + j;
j = i - j;
i = i - j;
System.out.println(i);
System.out.println(j);
}
}
4、比较运算符
== :比较左边与右边的值是否相等，如果相等结果true. 否则返回false
!= :比较左边与右边的值是否不相等，如果不相等返回true.否则返回false
> >= < <=.....
public class Demo8 {
public static void main(String[] args) {
int a = 5;
int b = 6;
System.out.println(a==b);//false
System.out.println(a!=b);//true
System.out.println(a >= 5);
/*
=与==的区别：
=是赋值符号，效果是将右边的值赋值给左边的变量
==是比较符号，效果是判断两边的值是否相等
*/
}
}
5、逻辑运算符
& ：并且 效果：连接两个条件，如果两个条件都成立，则整体成立
| : 或者 效果：连接两个条件，如果两个条件都不成立，则整体不成立
! : 取反 效果：本身的值是true,使用了取反符号就变成false
&& : 双与 也表示并且，但是带短路效果
|| : 双或 也表示或者，但是带短路效果
public class Demo9 {
public static void main(String[] args) {
//测试&符号
char gender = '男';
int age = 26;
System.out.println(gender=='女' & age > 20);
//测试 | 符号
int score = 100;//技术分数
int fs = 3;//颜值
System.out.println(score >=95 | fs >= 85);
//测试 ! 符号
System.out.println(!(score>=95));//false
}
}
public class Demo10 {
public static void main(String[] args) {
int i = 5;
/*
& 不带短路效果 所以任何情况下都会将两个条件都判断一次
这样是不合理的，因为如果第一个条件不成立了，则第二个条件就不需要判断了
在不影响整体结果值的情况下，不判断第二个条件，我们将这种情况称之为短路效果
*/
System.out.println(i > 5 & i++ < 6);//false
System.out.println(i);//6
int j = 5;
/*
使用&&符号 带短路效果
意思就是：在判断了第一个条件，如果就能决定整体的结果，则不会判断第二个条件
当前这个代码，第一个条件为false,就已经决定了整体的结果肯定为false
所以就触发了短路效果，不会判断第二个条件也就不会执行j++
所以j的值还是5
*/
System.out.println(j > 5 && j++ < 6);//false
System.out.println(j);//5
}
}
public class Demo11 {
public static void main(String[] args) {
int i = 5;
/*
| 不带短路效果 所以会将两个表达式都判断一次
*/
System.out.println(i >= 5 | i++ <= 9);//true
System.out.println(i);//6 int j = 5;
/*
|| 带短路效果
第一个条件已经能决定整体的结果了，就不会判断第二个条件了
*/
System.out.println(j >= 5 || j++ <= 9);//true
System.out.println(j);//5
}
}
6、位运算符(了解)
& :如果连接的是boolean表达式，则充当逻辑运算符
如果连接的是整数，则充当位运算符
将两个数字的二进制形式，每一位都进行运算，
如果两个数字都是1，则结果为1 否则结果为0
| :如果连接的是boolean表达式，则充当逻辑运算符
如果连接的是整数，则充当位运算符
将两个数字的二进制形式，每一位都进行运算，
如果两个数字有一个是1，则结果为1 否则结果为0
^ : 将两个数字的二进制形式，每一位都进行运算，
如果两个数字不相等，则结果为1
否则结果为0
>> :右移 将指定整型的二进制数向右边移动指定的位数。 右边移动的数字就丢失，左边会空出位置出来，
如果符号位是1则左边填1，如果符号位是0，则左边填0
<< : 左移 将指定整型的二进制数向做边移动指定的位数。
左边移动的数字就丢失，右边会空出位置出来，空出的位置填0
>>> :无符号右移 将指定整型的二进制数向右边移动指定的位数。
右边移动的数字就丢失，左边会空出位置出来，空出的位置填0
public class Demo12 {
public static void main(String[] args) {
int i = 15;
int j = 2;
/*
00000000 00000000 00000000 00001111
00000000 00000000 00000000 00000010
-------------------------------------
00000000 00000000 00000000 00000010
*/
System.out.println(i & j);//2
/*
00000000 00000000 00000000 00001111
00000000 00000000 00000000 00000010
-------------------------------------
00000000 00000000 00000000 00001111
*/
System.out.println(i | j);//15
/*
00000000 00000000 00000000 00001111
00000000 00000000 00000000 00000010
-------------------------------------
00000000 00000000 00000000 00001101
*/
System.out.println(i ^ j);//13
}
}
public class Demo13 {
public static void main(String[] args) {
int i = 8;
/*
00000000 00000000 00000000 00001000
右移之后的效果：
00000000 00000000 00000000 00000010 00
*/
System.out.println(i >> 2);//2
/*
00000000 00000000 00000000 00001000
左移之后的效果：
00000000 00000000 00000000 00100000
*/
System.out.println(i << 2);//32
int a = -24;
/*
-24 的原码： 10000000 00000000 00000000 00011000
-24 的反码： 11111111 11111111 11111111 11100111
-24 的补码： 11111111 11111111 11111111 11101000
向右移两位的效果：11111111 11111111 11111111 11111010
结果的反码：11111111 11111111 11111111 11111001
结果的原码：10000000 00000000 00000000 00000110
十进制：-6
无符号右移两位的效果：00111111 11111111 11111111 11111010
*/
System.out.println(a >> 2);
System.out.println(a >>> 2);
System.out.println(0b00111111111111111111111111111010);
}
}
练习
计算结果：
-12 >> 3
-12 >>> 3
public class Practise3 {
public static void main(String[] args) {
byte b = -12;
/*
-12的原码：10001100
-12的反码：11110011
-12的补码: 11110100
右移3位：11111110
结果的反码：11111101
结果的原码：10000010
十进制：-2
*/
System.out.println(b >> 3);
/*
-12的原码：10000000 00000000 00000000 00001100
-12的反码：11111111 11111111 11111111 11110011
-12的补码: 11111111 11111111 11111111 11110100
无符号右移3位：00011111 11111111 11111111 11111110
*/
System.out.println(b >>> 3);
System.out.println(0b00011111111111111111111111111110);
}
}
7、三目运算符
boolean表达式?java代码1:java代码2
特点：如果boolean表达式的值为true,则执行java代码1，否则执行java代码2
public class Demo14 {
public static void main(String[] args) {
int a = 6;
System.out.println(a>5?"a大于5":"a不大于5");
}
}
练习
定义两个整型变量并赋值使用三目运算符，打印更大的那一个值
2.
定义三个整型变量并赋值使用三目运算符，打印更大的那一个值
public class Practise5 {
public static void main(String[] args) {
/*
定义三个整型变量并赋值
使用三目运算符，打印更大的那一个值
*/
int a = 25;
int b = 12;
int c = 9;
System.out.println(a>b?(a>c?a:c):(b>c?b:c));
}
}
8、Scanner
这个单词本身是扫描仪的意思
在Java中可以扫描控制台的内容
要使用Scanner需要一些面向对象的思想
也就是通过操作对象来完成任务
类 ：相当于现实生活中的分类
对象：指定分类中的一个具体的事物
例如：手机可以打电话 手机表示分类 我的手机不见了 手机表示具体的一个事物
我们面向对象的思想：就是要先获取到一个具体的事务，然后操作它
Scanner表示一个分类，如果想要使用它，必须先从这个分类中创建一个具体的扫描仪对象出来
使用Scanner
- 导包
Scanner本身也是一个java Class,由jdk直接提供的
如果在a java类中要使用 b java类，则b java类必须与a类在同一个包中
如果不在同一个包则必须导包导包的方式：
在class上面，package下面
import 包名.类名;
- 创建Scanner类型的对象
Scanner scanner = new Scanner(System.in);
理解方式：
先看右边的值 new 表示新建的意思
Scanner 表示扫描仪分类
System.in 表示指定扫描控制台的内容
把右边连起来理解：创建一个扫描控制台内容的扫描仪对象
左边：就是创建一个名词为scanner的变量
然后将右边的对象 赋值给 左边的变量
那么以后就可以通过操作变量来操作这个扫描仪对象了
- 使用Scanner对象
通过调用对象方法的方式，可以完成指定的任务
方法：可以理解为某个对象的功能
int i = scanner.nextInt();
效果：
1.允许用户在控制台写数据
2.让扫描仪去扫描控制台的整型数据
import java.util.Scanner;//将Scanner类导入
public class Demo15 {
public static void main(String[] args) {
//创建Scanner类型的对象(相当于拿到了一个具体的扫描仪)
Scanner scanner = new Scanner(System.in);
/*
等待用户输入 并在用户输入完之后，自动的扫描输入的数据
用户通过按 回车键 通知扫描仪可以开始扫描了
*/
int i = scanner.nextInt();
System.out.println("您输入的数字是:" + i);
}
}
Scanner的其他功能
nextLine(); 扫描控制台的字符串数据
注意事项
如果使用nextInt方法来扫描控制台的数据
则在控制台输入的数据必须是整型，如果有了非数字的字符，会报错
解决方案：应该使用nextLine方法
练习
定义三个整型变量
使用Scanner输入三个值为这三个变量赋值
然后数组其中最小的哪一个值
import java.util.Scanner;
public class Practise6 {
public static void main(String[] args) {
/*
定义三个整型变量
使用Scanner输入三个值为这三个变量赋值
然后数组其中最小的哪一个值
*/
Scanner scanner = new Scanner(System.in);
int a,b,c;
a = scanner.nextInt();
b = scanner.nextInt();
c = scanner.nextInt();
System.out.println(a < b ?(a < c ? a : c) : (b < c? b : c));
}
}
9、选择结构
目前我们的程序，一定是会按顺序将每一行代码都执行
实际开发中，有可能出现的情况是：编写代码的时候，要考虑多个方案，也就是要写多种代码
但是实际执行的时候，要根据程序的运行环境或者用户的操作方式，要来选择执行其中的某一部分代码要达到这个效果，需要使用if语句
if(条件){
代码块;
}
如果条件成立，则执行代码块
如果条件不成立，则跳过这个代码块，不执行
if(条件){
if代码块;
}else
{
else代码块;
}
如果条件成立，则执行if代码块
如果条件不成立，执行else代码块
if(条件){}else if(条件){
}else if(条件){
}....[else{}]
从上往下依次判断每一个条件
如果某一个条件成立，则执行对应的代码块，然后结束整个if结构
如果条件不成立，则判断下一个条件如果所有条件都不成立：
没有最后的else: 则整个结构没有执行的代码块，结构结束
有最后的else: 则执行else中的代码块
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的年龄：");
int age = scanner.nextInt();
if(age >= 22){
System.out.println("你可以结婚了，但是你得有女朋友!");
}
}
}
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("同学，请输入您的分数: ");
double score = scanner.nextDouble();
if(score >= 60){
System.out.println("挂 科比 不挂 柯南");
}else{
System.out.println("不挂 科比 挂 柯南");
}
}
}
import java.util.Scanner;
public class Demo3 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的分数:");
double score = scanner.nextDouble();
//判断这个分数属于哪一个等级
if(score == 100){
System.out.println("perfect!");
}else if(score >= 90){
System.out.println("great!");
}else if(score >= 80){
System.out.println("good!");
}else if(score >= 70){
System.out.println("so so");
}else if(score >= 60){
System.out.println("及格");
}else {
System.out.println("不及格");
}
}
}
嵌套的if语句
if(条件1)
{
if(条件2){
}
}
练习
声明3个变量,使Scanner输入赋值，然后使用if语句找出最大的那一个变量的值输出
import java.util.Scanner;
public class Practise {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a,b,c;
a = scanner.nextInt();
b = scanner.nextInt();
c = scanner.nextInt();
//1写法一 使用if语句与&&运算符
if(a >= b && a >= c){
System.out.println("最大值：" + a);
}else if(b >= a && b >= c){
System.out.println("最大值:" + b);
}else{
System.out.println("最大值:" + c);
}
//写法二 使用嵌套的if
if(a > b){
if(a > c){
System.out.println("最大值:" + a);
}else{
System.out.println("最大值:" + c);
}
}else{
if(b > c){
System.out.println("最大值:" + b);
}else{
System.out.println("最大值:" + c);
}
}
}
}
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
