标签：Java 00000000 基础 System ++ println true out
Java基础（一）
1、变量与数据类型
1、数据类型
/*
java是一门强类型语言。
变量：指的是在java程序运行过程中，其值可以发生改变的量
定义一个变量的语句定义格式：
数据类型 变量名 = 初始化值;
数据类型：
基本数据类型：
整数类型： 所占的字节数 可表示的范围
byte 1 -2^7 ~ 2^7-1
short 2 -2^15 ~ 2^15-1
int 4 -2^32 ~ 2^32-1
long 8 -2^63 ~ 2^63-1
小数类型：
float 4
double 8
布尔类型：
boolean 1
字符类型：
char 根据具体的编码来定，不同的编码下，java中一个字符所占的字节数是不同的
引用数据类型：【今天不说】
使用变量的注意事项：
1、变量要进行初始化赋值，才可以进行使用
2、在同一作用域下，变量名不能重复，可以大小写不一样，严格区分大小写的。
3、java中整数默认是int类型，要想定义一个long类型的变量，需要在值的末尾加上L或者l，推荐使用L
4、java中小数默认是double类型，要想定义一个float类型的变量，需要在值的末尾加上F或者f，推荐使用F
*/
public class DataTypeDemo1 {
public static void main(String[] args) {
//数据类型 变量名 = 初始化值;
//定义一个byte类型的变量
byte b1 = 100;
// b1 = 120;
// byte b1;
// byte B1 = 110;
System.out.println(b1); // 直接打印这个变量，实际上打印的是该变量存储的值
//定义一个short类型的变量
short s1 = 200;
System.out.println(s1);
//定义一个int类型的变量
int i1 = 300;
System.out.println(i1);
// int i2 = 30000000000;
long i2 = 30000000000L;
System.out.println(i2);
//定义一个float类型的变量
float f1 = 12.34F;
System.out.println(f1);
//定义一个double类型的变量
double d1 = 33.45;
System.out.println(d1);
//定义一个布尔类型的变量
boolean b2 = true;
System.out.println(b2);
//创建一个字符变量
char c1 = 'a';
System.out.println(c1);
}
}
/*
在java中，变量参与运算的时候，会先自动提升数据类型
自动数据类型转换：
byte,short,char -> int -> long -> float -> double
强制数据类型转换：
语句定义格式：
目标数据类型 变量名 = (目标数据类型)(要转型的值或表达式)
注意：今后尽量不要用，可能会损失精度。
*/
public class DataTypeDemo2 {
public static void main(String[] args) {
byte a1 = 3;
byte a2 = 4;
// byte a;
// a =(byte)(a1 + a2);
int a;
a = a1 + a2;
System.out.println(a);
}
}
/*
计算机中的数据都是采用补码进行运算的
130的补码：00000000 00000000 00000000 10000010
做强制类型转换：
补码： (00000000 00000000 00000000) 10000010
补码： 10000010
已知补码求原码：
符号位 数值位
补码： 1 0000010
反码： 1 0000001
原码： 1 1111110
-----------------------------
64 + 32 + 16 + 8 + 4 + 2 = 126
因为符号位是1，所以最终的结果是-126
*/
public class DataTypeDemo3 {
public static void main(String[] args) {
byte a;
a = (byte)(130);
System.out.println(a);
}
}
/*
System.out.println('a');
System.out.println('a'+1);
System.out.println("hello"+'a'+1);
System.out.println('a'+1+"hello");
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");
注意：
1、+ 号两边若都没有字符串，这个就是最普通的算数加法运算
2、若有字符参与算数运算的话，java虚拟机会将该字符所对应的ASCII码表中的数值进行转换
记住三个特殊的字符对应的ASCII码值：
'0' - 48
'A' - 65
'a' - 97
3、同级别优先级的符号，从左向右进行运算
4、+ 号两边若任意一边是字符串，而是做字符串的左右拼接操作，拼接结束后是一个新的字符串
*/
public class DataTypeDemo4 {
public static void main(String[] args) {
//代码格式化的快捷键：ctrl + alt + L
// System.out.println('a'); // a
// System.out.println('a' + 1); // 98
System.out.println("hello" + 'a' + 1); // helloa1
System.out.println('a' + 1 + "hello"); // 98hello
System.out.println("5+5=" + 5 + 5); // 5+5=55
System.out.println(5 + 5 + "=5+5"); // 10=5+5
System.out.println("5+5=" + (5+5)); // 5+5=10
}
}
2、算术、赋值、关系、逻辑、位运算符
1、算术运算符
/*
算数运算符：
+ - * / % ++ --
java中，一个算数表达式最终的结果数据类型，是由参与运算最大的那个参数类型决定的。
*/
public class SuanShuDemo1 {
public static void main(String[] args) {
int a = 12;
float b = 1.2F;
System.out.println(a/b);
}
}
/*
++: 自加1
++在后，先赋值再进行自加1；++在前，先自加1，再赋值参与运算
--: 自减1
--在后，先赋值再进行自减1；--在前，先自减1，再赋值参与运算
*/
public class SuanShuDemo2 {
public static void main(String[] args) {
/**
* 单独使用
*/
int a = 3;
int b = 4;
System.out.println("a: " + a);
System.out.println("b: " + b);
System.out.println("-----------------------------");
// a++;
// b++;
// ++a;
// ++b;
// System.out.println("a: " + a);
// System.out.println("b: " + b);
/**
* 混合使用
*/
// int x = a++;
// System.out.println(x); // 3
int x2 = ++a;
System.out.println(x2);
}
}
2、赋值运算符
/*
赋值运算符：
= += -= *= /= %=
*/
public class FuZhiDemo1 {
public static void main(String[] args) {
int a = 3;
// a += 4;
// System.out.println(a);
a-=5;
System.out.println(a);
}
}
/*
short s=1, s = s+1;
short s=1, s+=1;
*/
public class FuZhiDemo2 {
public static void main(String[] args) {
// short s = 1;
// s = (short) (s + 1);
// System.out.println(s);
short s = 1;
s += 1; // s = (short) (s + 1);
System.out.println(s);
}
}
3、比较运算符
/*
关系运算符：
> < >= <= != ==
关系表达式的结果一定是boolean类型的
*/
public class GuanXiDemo1 {
public static void main(String[] args) {
int a = 3;
int b = 4;
System.out.println(a==b); // false
// System.out.println(a=b); // 4
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a<=b);
System.out.println(a>=b);
System.out.println(a!=b);
}
}
4、逻辑运算符
/*
逻辑运算符：
& | ^ ! && ||
逻辑运算符，参与运算的参数类型是boolean，结果也是一个boolean类型的
*/
public class LuoJiDemo1 {
public static void main(String[] args) {
int a = 3;
int b = 4;
// & 有false则false
// System.out.println((a++>3)&(b++>4)); // false & false = false
// System.out.println("a: " + a + ", b: " + b);
// System.out.println((a++>3)&(b++==4)); // false & true = false
// System.out.println((a++==3)&(b++>4)); // true & false = false
// System.out.println((a++==3)&(b++==4));// true & true = true
// && 短路与 当左边为false的时候，右边表达式不会执行，结果为false
// System.out.println((a++ > 3) && (b++ > 4)); // false && false = false
// System.out.println("a: " + a + ", b: " + b);
// System.out.println((a++ > 3) && (b++ == 4)); // false && true = false
// System.out.println((a++ == 3) && (b++ > 4)); // true && false = false
// System.out.println((a++ == 3) && (b++ == 4));// true && true = true
// | 有true则true
// System.out.println((a++ > 3) | (b++ > 4)); // false | false = false
// System.out.println((a++ > 3) | (b++ == 4)); // false | true = true
// System.out.println((a++ == 3) | (b++ > 4)); // true | false = true
// System.out.println((a++ == 3) | (b++ == 4));// true | true = true
// System.out.println("a: " + a + ", b: " + b);
// || 短路或 当左边为true的时候，右边表达式不会执行，结果为true
// System.out.println((a++ > 3) || (b++ > 4)); // false || false = false
// System.out.println((a++ > 3) || (b++ == 4)); // false || true = true
// System.out.println((a++ == 3) || (b++ > 4)); // true || false = true
// System.out.println((a++ == 3) || (b++ == 4));// true || true = true
// System.out.println("a: " + a + ", b: " + b);
// System.out.println(100>a>10) // java中不允许出现连续比较
System.out.println(a>10 && a<100);
// ^ 异或 相同则false,不同则true
// System.out.println((a++ > 3) ^ (b++ > 4)); // false ^ false = false
// System.out.println((a++ > 3) ^ (b++ == 4)); // false ^ true = true
// System.out.println((a++ == 3) ^ (b++ > 4)); // true ^ false = true
// System.out.println((a++ == 3) ^ (b++ == 4));// true ^ true = false
//! 将true变成false, false变成true
// System.out.println(!(a++ > 3));
}
}
5、位运算符
/*
位运算符：针对数值2进制形式的计算
& | ^ ~ >> << >>>
位运算符，参与运算的是数值，结果也是一个数值
*/
public class WeiDemo1 {
public static void main(String[] args) {
int a = 3;
int b = 4;
// System.out.println(a&b);
// System.out.println(a|b);
// System.out.println(a^b);
System.out.println(~a);
}
}
/*
计算机中所有的运算都是采用补码进行的
3的补码：00000000 00000000 00000000 00000011
4的补码：00000000 00000000 00000000 00000100
&：有0则0
00000000 00000000 00000000 00000011
&
00000000 00000000 00000000 00000100
-------------------------------------
00000000 00000000 00000000 00000000
|：有1则1
00000000 00000000 00000000 00000011
|
00000000 00000000 00000000 00000100
-------------------------------------
00000000 00000000 00000000 00000111
^：相同则0，不同则1
00000000 00000000 00000000 00000011
^
00000000 00000000 00000000 00000100
-------------------------------------
00000000 00000000 00000000 00000111
~： 0变成1，1变成0
00000000 00000000 00000000 00000011
~
-------------------------------------
补码 11111111 11111111 11111111 11111100
反码 11111111 11111111 11111111 11111011
原码 10000000 00000000 00000000 00000100
-----------------------------------------
-4
============================================================================================
/*
>>:右移，整体补码向右移动若干位，右边多出的部分丢弃，若最高位是1，左边就用1补齐；反之用0补齐
<<:左移，整体补码向左移动若干位，左边多出的部分丢弃，右边用0补齐
>>>:无符号右移，整体补码向右移动若干位，右边多出的部分丢弃，左边无论最高位是0还是1，都用0补齐
*/
public class WeiDemo2 {
public static void main(String[] args) {
System.out.println(24>>2); // 24/2^2 = 6
System.out.println(2<<4); // 2*2^4 = 32
System.out.println(-24>>>2); // 1073741818
}
}
/*
24的补码：00000000 00000000 00000000 00011000
00000000 00000000 00000000 00011000
>>2: 00000000 00000000 00000000 00000110(00)
------------------------------------------------
2的补码：00000000 00000000 00000000 00000010
00000000 00000000 00000000 00000010
<<4: (0000)00000000 00000000 00000000 00100000
-24
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
------------------------------------------
11111111 11111111 11111111 11101000
>>>2: 0011111111 11111111 11111111 111010(00)
*/
*/
6、三目运算符(三元运算符)
/*
三目运算符【三元运算符】：
语句定义格式：
(关系表达式)?表达式1:表达式2;
这里的表达式1和表达式2必须是要有一个结果值的。
*/
public class SanMuDemo1 {
public static void main(String[] args) {
int a = 3;
int b = 8;
//需求：求两个数中的最大值
// int x = (a > b) ? a : b;
// System.out.println(x);
// (a > b) ? System.out.println(a) : System.out.println(b);
}
}
3、Scanner if语句
1、键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，我准备把数据改进为键盘录入，提高程序的灵活性。
如何实现键盘录入数据呢?(目前先记住使用)
导包(位置放到class定义的上面)
import java.util.Scanner;
创建对象
Scanner sc = new Scanner(System.in);
接收数据
int x = sc.nextInt();
import java.util.Scanner;
/*
键盘录入:程序运行过程中，用户可以根据自己的需求输入参与运算的值
今天只需要掌握如何使用即可，不需要关系细节，后面会再说
实现键录入的步骤：
1、导包
2、创建键盘录入对象
3、调用方法实现键盘录入
1）输入整数
2）输入字符串
Scanner，是jdk1.5之后出现的，思考：jdk1.5之前人们想要手动输入数据的话，怎么办？
*/
public class ScannerDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的名字：");
// int i = sc.nextInt();
// System.out.println(i);
String name = sc.next();
System.out.println(name);
}
}
2、选择结构（if语句）
import java.util.Scanner;
/*
选择结构：
if选择语句
switch选择语句
if选择语句:
语句定义格式1：
if(关系表达式){
语句体;
}
注意事项：
1、if小括号中的语句，可以很复杂，但是最终的结果一定是boolean类型
2、只有当if语句体中的语句只有一行的时候，大括号才可以省略，建议永远不要省略大括号
3、小括号后面可以添加分号，相当于if语句拥有一个空的语句体
*/
public class IfDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入江川的性别：");
String gender = sc.next();
//A
//B
//A.equals(B)
if("男".equals(gender));{
System.out.println("去男厕所");
System.out.println("洗手");
}
}
}
=============================================================================================
/*
if语句定义格式2：
if(关系表达式){
语句体1;
}else{
语句体2;
}
注意：
if-else语句中，只会执行其中某一个语句体，不会同时都执行！
*/
public class IfDemo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入江川的性别：");
String gender = sc.next();
//A
//B
//A.equals(B)
if("nan".equals(gender)){
System.out.println("去男厕所");
System.out.println("洗手");
}else {
System.out.println("去女厕所");
System.out.println("洗手");
}
}
}
4、switch语句 for循环
import java.util.Scanner;
/*
switch选择语句：
语句定义格式：
switch(表达式){
case 常量值1:
表达式1;
break;
case 常量值2:
表达式2;
break;
...
default:
表达式n;
break;
}
执行流程：严格按照下面的流程执行。
1、先计算表达式中的值
2、然后拿着计算出来的值自上而下匹配所有的case，当某一个case后面的常量值与计算出来的值一样的时候，
执行其中的语句体，遇到break，结束整个switch语句.
3、当所有的case都不匹配的时候，执行default中的语句体，当遇到break的时候，结束整个switch语句.
注意：
1、表达式的取值：byte,short,int,char,枚举,String
2、case后面只能跟常量，不能是变量
3、break能不能不写？能不写，但是会发生switch穿透！
4、default语句能不能不写？可以不写，但是为了程序的严谨性，最好加上
5、default语句是不是一定要放在所有case之后呢？不一定，可以放在switch语句中的任意位置
*/
public class SwitchDemo {
public static void main(String[] args) {
//假设我们所带的金额，正好是购买一瓶饮料的价格，多了或少了都买不了，只有正好才可以消费
//可乐 3，脉动 5，红牛 7，ad钙奶 4
System.out.println("请输入您带的金额：");
Scanner sc = new Scanner(System.in);
int price = sc.nextInt();
switch (price) {
case 3:
System.out.println("欢迎购买一瓶 可乐！");
break;
case 4:
System.out.println("欢迎购买一瓶 ad钙奶！");
break;
case 5:
System.out.println("欢迎购买一瓶 脉动！");
break;
case 7:
System.out.println("欢迎购买一瓶 红牛！");
break;
default:
System.out.println("没有您所带金额的饮料！！");
break;
}
}
}
============================================================================================
for循环
/*
for循环：
语句定义格式：
for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
}
注意事项：
1、初始化条件语句，有且仅执行一遍
2、初始化条件语句可以写在for循环的外面，和定义在for循环内部时比较，作用域不同
3、大括号可以省略，但是省略后只能作用在第一条语句上，建议，永远不要省略
4、判断条件语句能否不写？可以不写，但是会变成死循环
5、控制条件语句也可以不写，但是可能会是死循环
一个最简单的for死循环：
for(;;){
....
}
*/
public class ForXunDemo1 {
public static void main(String[] args) {
//需求：在控制台中输出10行helloworld
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
// System.out.println("helloworld");
//初始化语句：定义一个变量表示范围，每循环一次需要改变一次 int i = 1
//判断条件语句：10行：范围 1-10 i<=10
//控制条件语句：i++
//循环体语句：System.out.println("helloworld");
//使用for循环改进
// int i = 1;
for (int i = 1; i <= 10;i++) {
System.out.println("helloworld - " + i);
// System.out.println("helloworld - " + i);
}
// System.out.println(i);
}
}
============================================================================================
/*
请在控制台输出数据1-10
请在控制台输出数据10-1
求出1-10之间数据之和
求出1-100之间偶数和
求出1-100之间奇数和
求5的阶乘【自己实现】
在控制台输出所有的”水仙花数”，统计”水仙花数”共有多少个
*/
public class ForTest {
public static void main(String[] args) {
//请在控制台输出数据1-10
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}
System.out.println("------------------------");
//请在控制台输出数据10-1
for (int i = 10; i > 0; i--) {
System.out.println(i);
}
System.out.println("------------------------");
//求出1-10之间数据之和
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}
System.out.println("1-10之间的和为：" + sum);
System.out.println("------------------------");
//求出1-100之间偶数和
//求出1-100之间奇数和
int ouSum = 0;
int jiSum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
ouSum += i;
} else {
jiSum += i;
}
}
System.out.println("1-100之间的偶数和为：" + ouSum);
System.out.println("1-100之间的奇数和为：" + jiSum);
System.out.println("------------------------");
int count = 0;
for (int i = 100; i < 1000; i++) {
int baiWei = i / 100;
int shiWei = i % 100 / 10;
int geWei = i % 10;
if ((baiWei * baiWei * baiWei + shiWei * shiWei * shiWei + geWei * geWei * geWei) == i) {
System.out.println(i);
count++;
}
}
System.out.println("水仙花数共计 " + count + " 个");
}
}
============================================================================================
/*
需求：在控制台输出九九乘法表。
*/
public class ForTest2 {
public static void main(String[] args) {
// 需求1：在控制台中输出5行5列的*
//输出一行
// System.out.println(); //换行输出
// System.out.print(); // 不换行输出
// System.out.print("*\t"); // \t -> Tab键 -> 默认是4个空白字符
// System.out.print("*\t");
// System.out.print("*\t");
// System.out.print("*\t");
// System.out.print("*\t");
//使用for循环输出一行*
// for(int i=1;i<=5;i++){
// System.out.print("*\t");
// }
// System.out.println();
//
// for(int i=1;i<=5;i++){
// System.out.print("*\t");
// }
// System.out.println();
//
// for(int i=1;i<=5;i++){
// System.out.print("*\t");
// }
// System.out.println();
//
// for(int i=1;i<=5;i++){
// System.out.print("*\t");
// }
// System.out.println();
//
// for(int i=1;i<=5;i++){
// System.out.print("*\t");
// }
// System.out.println();
//使用循环打印5行
//双重for循环
for (int i = 1; i <= 5; i++) { // 外层循环控制的是行数
for (int j = 1; j <= 5; j++) { //内层循环控制的是列数
System.out.print("*\t");
}
System.out.println();
}
System.out.println("------------------------------------");
// 需求2：在控制台中输出三角形的*
/*
* 第 1 行，共 1 列
* * 第 2 行，共 2 列
* * * 第 3 行，共 3 列
* * * * 第 4 行，共 4 列
* * * * * 第 5 行，共 5 列
... 第 n 行，共 n 列
*/
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*\t");
}
System.out.println();
}
System.out.println("------------------------------------");
//在控制台输出九九乘法表。
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (i * j)+"\t");
}
System.out.println();
}
}
}
标签：Java,
00000000,
基础,
System,
++,
println,
true,
out
From： https://www.cnblogs.com/snzjz/p/18475127