标签：生活 int System 改变 println Java public out
Java改变生活（一）
生活的不易与诗和远方
生活像泥泞的沼泽，一旦陷入就要在其中奋力挣扎，没有技巧很难脱身奔赴远方，作那逍遥的诗人于世间欢颂疾苦。
Java的前世今生
序幕 ：
1991年，身处于American电子技术浪潮中心的Sun公司为开发分布式结构系统，使其产品能应用于各种各样的电子产品，开拓电子产品的消费市场而成立了Java语言小组，传奇的语言也因此拉开序幕。
诞生 ：
那个时代，许多语言都采用面向过程设计的模式，但开发人员在进行大规模项目的构造同时，面向过程设计模式的缺点慢慢被揭露。为解决这一系列麻烦，Java语言小组决定另辟蹊径——面向对象设计模式。
起初，Java想在C的基础上完成语言类型的进化转换，随着实验的进行，该想法也烟消云散。就在这一筹莫展之际，Java小组决定铤而走险，既然没有适合我们的语言，那我们就创造适合我们的，于是Java根据C++的一些特性开始创造。由此实质性的Java语言诞生了！
开始 ：
1995年，Java语言首次出现在世人眼前，几个月后，Java语言凭借其独特的气质一鸣惊人，完成了出道即巅峰，那时网络上弥漫着数不清的Java小程序，一股Java浪潮席卷了整个网络，而这也是Java传奇的开始。
未来 ：
如今，Java语言经过多年的完善和更新迭代，已经成为各大公司开发的热门语言，并且应用于各种各样不同的领域。博主认为Java语言不仅仅是开发工具，它带给我们的是一种思维模式，在学习Java的过程中要注重开发思维和代码配合的均衡。
传奇仍在继续！
Java的特性
- 简单性
Java语言剔除了C++许多晦涩难懂、容易混淆的特性，在我们看来Java就是C++的一个“纯净”版本。但是随着更新迭代，如今的Java在许多方面都要远超于C++。
另一个方面是Java的小，它可以用极小的空间进行开发，也正是因为这特性，Java非常适合嵌入式开发。 - 面向对象
Java语言采用面向对象的设计模式，面向对象就是关注事物整体，用木匠做比喻，面向对象在进行制作木具时，首先考虑做什么样的，而不是使用什么工具进行制作。 - 分布式
Java语言利用丰富的例程库处理TCP/IP协议，因此Java应用程序能过通过URL快速便捷的打开和访问网络上的对象。 - 健壮性
Java语言是非常可靠的，它有三板斧来保证程序的健壮性，前期的编译器检测，运行时的动态检测，以及异常机制的配合。 - 安全性
Java语言最初就建立了安全结构系统，通过防止运行时的堆栈溢出、破坏进程外的内存空间、未经授权读写文件等手段来防范各种攻击。 - 体系结构中立
Java语言利用虚拟机编译一种结构中立的特定编码，利用虚拟机可以完成特定代码和机器码的转换，因此只要有Java虚拟机便可以运行Java代码，与系统无关。 - 可移植性
Java语言对基本数据类型的大小以及有关运算的行为都有明确的说明，不会因为不同的环境导致数据的更改与结果的不同，消除了代码移植的差异性。 - 解释型
Java语言的解释器可以将Java字节码转换成机器码并运行，因此Java解释器可以在任何机器上执行Java代码，提高了开发过程的速度。 - 高性能
Java语言的编译器可以监控某些代码段会频繁执行，并主动优化这些代码以提高速度，也还可以消除函数调用的内联性。 - 多线程
Java语言支持并发操作，也就是多个任务“同时”工作。大大提高了项目的性能。 - 动态性
Java语言可以适应不同的环境，因为在对Java库进行增添修改的操作时，只要不改变发布给客户端的接口，就可以在不对客户端产生影响的情况下实现不同的功能或对代码进行优化。
Java的基础语法
- 注释
| Type | Value |
|---|---|
| 单行注释 | // content |
| 多行注释 | /* content */ |
| 文档注释 | /** content */ |
package Demo;
/**
* This is the first program in our study
* 可以利用Javadoc完成转换，平时我们查看的Java帮助文档就是这样来的
* @version 1.1 2021-02-15
* @author JackXu
* */
public class Test {
public static void main(String[] args) {
//单行注释
System.out.println("单行注释");
/*
* 多行注释
* 1
* */
System.out.println("多行注释");
}
}
输出结果
单行注释
多行注释
- 数据类型、变量与常量
| 整型 | 字节 |
|---|---|
| byte | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| 浮点型 | 字节 |
|---|---|
| float | 4 |
| double | 8 |
| 字符型 | 字节 |
|---|---|
| char | 2 |
| 布尔型 | 字节 |
|---|---|
| boolean | 1 |
package Demo;
public class Test {
public static void main(String[] args) {
/*
* 变量创建格式：数据类型+名=值
* 常量用final加以修饰，命名潜规则一般用大写
* long和float赋值时需要在后面加l和f，大小写都可以
* */
byte b=1;
short s=1;
final int CHANGLIANGINT = 1;
long l=1l;
float f=1.5f;
double i = 1.5;
char c='a';
boolean bool=false;
System.out.println(b+s+CHANGLIANGINT+l+f+i+c);
System.out.println(bool);
}
}
输出结果
104.0
false
- 运算符
| 算术运算符 | 说明 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 求余 |
| ++ | 自增 1 |
| - - | 自减 1 |
package Demo;
public class Test {
public static void main(String[] args) {
/*
* 混合运算时类型会自动提升
* 求余两边必须是整型数据
* 自增自减
* a++（a--）先使用a的值运算，结束后a+1或a-1
* ++a（--a）先a+1或a-1，再将增或减后的值进行运算
* */
byte a=1;
short b=2;
int c=3;
long d=4l;
float e=5.5f;
double f=6.5;
char g='a';
System.out.println(a+b+c+d+e+f+g);
System.out.println(b-a);
System.out.println(c*b);
System.out.println(d/b);
System.out.println(c%b);
System.out.println(a++);
System.out.println(--a);
}
}
输出结果
119.0
1
6
2
1
1
1
合法转换指示图
实线表示无信息丢失转换，虚线表示可能出现精度损失
| 比较运算符 | 说明 |
|---|---|
| > | 大于 |
| < | 小于 |
| >= | 大于或等于 |
| <= | 小于或等于 |
| == | 等于 |
| != | 不等于 |
package Demo;
public class Test {
public static void main(String[] args) {
// 比较运算符均是左结合性，即以左为主，例如a>b，就是看a是否大于b，大为真，小为假
byte a = 1;
short b = 2;
int c = 3;
System.out.println(a > b);
System.out.println(a < b);
System.out.println(a == b);
System.out.println(a != b);
System.out.println(b >= c);
System.out.println(b <= c);
}
}
输出结果
false
true
false
true
false
true
| 逻辑运算符 | 说明 |
|---|---|
| ！ | 非 |
| & | 与 |
| | | 或 |
| && | 短路与 |
| || | 短路或 |
package Demo;
public class Test {
public static void main(String[] args) {
/*短路的非与或，就是运算时当左边的值满足条件时便不看右边的表达式了
* 并且||、&&、！都只能接受boolean型数据
* */
int i = 0;
int j = 1;
System.out.println(i & j);
System.out.println(i | j);
System.out.println(false && true);
System.out.println(true || false);
System.out.println(!(true));
}
}
输出结果
0
1
false
true
false
| 位运算符 | 说明 |
|---|---|
| << | 左移一位 |
| >> | 右移一位 |
| >>> | 无符号右移一位 |
| | | 按位或 |
| & | 按位与 |
| ~ | 按位取反 |
| 位运算符适用类型 | |
| byte | |
| short | |
| int | |
| long | |
| char |
package Demo;
public class Test {
public static void main(String[] args) {
Integer a = -19;
Integer b = Integer.MIN_VALUE;
Integer c = 8;
System.out.println("右移");
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toBinaryString(a >> 2)); // 有符号右移
System.out.println(Integer.toBinaryString(a >>> 2)); // 无符号右移
System.out.println("负数左移");
System.out.println(Integer.toBinaryString(b));
System.out.println(Integer.toBinaryString(b << 2));
System.out.println("正数左移");
System.out.println(Integer.toBinaryString(c));
System.out.println(Integer.toBinaryString(c << 2));
System.out.println("按位与");
System.out.println(Integer.toBinaryString(c));
System.out.println(Integer.toBinaryString(22));
System.out.println(Integer.toBinaryString(c &22));
System.out.println("按位或");
System.out.println(Integer.toBinaryString(c));
System.out.println(Integer.toBinaryString(33));
System.out.println(Integer.toBinaryString(c|33));
System.out.println("按位非");
System.out.println(Integer.toBinaryString(c));
System.out.println(Integer.toBinaryString(~c));
}
}
位运算之前需要先学习一下二进制运算方法。之后可以根据下面结果进行理解。代码中运用的Integer以后的文章会进行介绍！
输出结果
右移
11111111111111111111111111101101
11111111111111111111111111111011
111111111111111111111111111011
负数左移
10000000000000000000000000000000
0
正数左移
1000
100000
按位与
1000
10110
0
按位或
1000
100001
101001
按位非
1000
11111111111111111111111111110111
| 混合赋值运算符 | 说明 |
|---|---|
| += | 加法赋值 |
| -= | 减法赋值 |
| *= | 乘法赋值 |
| /= | 除法赋值 |
| %= | 模运算赋值 |
| <<= | 左移赋值 |
| >>= | 右移赋值 |
| &= | 位逻辑与赋值 |
| |= | 位逻辑或赋值 |
| ^= | 位逻辑异或赋值 |
package Demo;
public class Test {
public static void main(String[] args) {
/*
* 混合赋值运算符就是将运算和赋值一同进行，其最重要的一点便是自动进行类型转换。
* 例如j-=2 实际运算时就变成j=j-2.3 然后将结果转换成j的类型再赋值给j
* */
int i = 0;
int j = 5;
System.out.println(i += (1 + 2 / 3) + 4.5);
System.out.println(j -= 2.3);
System.out.println(j *= 3);
System.out.println(j /= 4);
}
}
输出结果
5
2
6
1
- 运算符优先级
- 数组
package Demo;
public class Test {
public static void main(String[] args) {
/*
* 创建数组用new+数据类型[（数据个数）]
* 多维数组就是数组嵌套
* 例如new int[2][2][4]就是一个三维数组
* 从for循环的嵌套可以看出该三维数组的嵌套结构。
* arg这个三维数组里面有两个二维数组i，每个二维数组i还拥有一套一维数组j，所以包含数据就是2*2*4个
* */
int[] array = new int[3];
int[][][] arg = new int[2][2][4];
int s = 0;
for (int[][] i :
arg) {
for (int[] j :
i) {
for (int k :
j) {
System.out.print(k);
s++;
}
System.out.println();
}
System.out.println();
}
System.out.println(s);
}
}
输出结果
0000
0000
0000
0000
16
Java流程控制
- 顺序结构
package Demo;
public class Test {
public static void main(String[] args) {
/*
* 变量的作用域是由{}块决定的
* 可以利用该特性将不同功能的变量控制在不同的作用域
* */
int x = 20;
{
int y = 40;
System.out.println(y);
int z = 245;
boolean b;
{
b = y > z;
System.out.println(b);
}
}
//System.out.println(b);该语句将会报错，因为b已经超出其作用域了
System.out.println("hello java");
}
}
输出结果
40
false
hello java
- 选择结构
| 分支标记 | 说明 |
|---|---|
| if | 单分支 |
| if-else | 双分支 |
| switch-case | 多分支 |
| if-else嵌套 | 嵌套实现多分分支 |
package Demo;
public class Test {
public static void main(String[] args) {
int i = 5;
// if单分支,先判断条件，为真进入语句体，为假跳过语句体继续执行
if (i < 10) {
System.out.println("i的值小于10（if的判断条件为真）我被执行");
}
// if-else双分支，先判断条件，为真进入if的语句体，为假进入else的语句体
if (i > 10) {
System.out.println("i的值大于10（if的判断条件为真）我被执行");
} else {
System.out.println("如果i的值小于或等于10（if的判断条件为假）我被执行");
}
/*
if-else嵌套实现条件的排除法
例如判断一个数比0大、小、或等于
首先判断是否比0大，否的话就剩等于或小于
然后判断是否等于0，否的话就一定是小于
* */
if (i > 0) {
System.out.println("我大于0");
} else if (i == 0) {
System.out.println("我等于0");
} else {
System.out.println("我小于0");
}
/*
switch-case语句，传入一个数值，在case里面寻找对应值作为入口
从某个case的入口进去后一直向下执行，直到遇到break退出，或者执行到最后一句
*/
switch (i) {
case 1:
System.out.println("我是1");
case 2:
System.out.println("我是2");
case 3:
System.out.println("我是3");
case 4:
System.out.println("我是4");
case 5:
System.out.println("我是5");
case 6:
System.out.println("我是6");
case 7:
System.out.println("我是7");
case 8:
System.out.println("我是8");
break;
case 9:
System.out.println("我是9");
case 10:
System.out.println("我是10");
default:
System.out.println("我是10之外的数");
}
}
}
输出结果
i的值小于10（if的判断条件为真）我被执行
如果i的值小于或等于10（if的判断条件为假）我被执行
我大于0
我是5
我是6
我是7
我是8
- 循环结构
| 循环标记 | 说明 |
|---|---|
| while | 先判断后执行 |
| do-while | 先执行后判断 |
| for | 可控制次数的循环 |
| foreach | 一次性迭代，for的封装使用 |
| 控制循环 | 说明 |
|---|---|
| break | 退出本循环 |
| continue | 结束本次循环，进入下次循环 |
| 带标记的break和continue | 退出或继续到指定位置 |
package Demo;
public class Test {
public static void main(String[] args) {
//利用循环输出1-10
int i = 1;
/*
* while循环，先判断条件，为真进入执行，代码块执行完毕后在返回判断条件进行判断，直到条件为假退出
* 注意：
* 判断条件的界限要分清，在语句体里一定要将控制的变量进行更改。
* */
while (i < 11) {
System.out.print(i++ + " ");
}
System.out.println();
/*
* do-while循环，先执行代码块，在判断条件，直到条件为假退出
* 注意：
* 代码会先执行，因此次数会有所出入.
* while后面要有;
*
* */
int j = 10;
do {
System.out.print(j-- + " ");
} while (j > 0);
System.out.println();
//找出1-10之内的偶数
/*
* for循环括号有三个部分，中间用;隔开
* 第一部分控制变量初始化，第二部分控制条件，第三部分控制变量值的改变
* 注意：
* 条件都可以省略，但是代码其余位置必须有体现
* */
for (int k = 1; k < 11; k++) {
if (k % 2 == 0) {
System.out.print(k + " ");
}
}
System.out.println();
/*
* foreach用于一次性遍历，一般用于容器或者数组之类
* */
int[] ints = {1, 3, 5, 7, 9};
for (int o :
ints) {
System.out.print(o + " ");
}
/*
* 标记可以任意命名，一般都是有含义的，例如：loop
* 可以用break或者continue直接对所在循环进行操作
* 也可以用break或者continue对标记的循环进行操作
* 建议尽量不用标记退出，容易破坏程序结构
* */
System.out.println();
loop:
for (int a = 1; a < 88888; a++) {
for (int b = 1; b < 66666; b++) {
if (a == 5) {
break loop;
}
System.out.print("*");
if (b == a) {
System.out.println();
continue loop;
}
}
}
}
}
输出结果
1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
2 4 6 8 10
1 3 5 7 9
*
**
***
****
总结
本章介绍了Java最基本的语法和一些程序结构，可能有些地方总结或是理解的不够得到，希望大家能够多多指出、一起交流探讨。不断增强自身的能力以实现梦想!加油
标签：生活,int,System,改变,println,Java,public,out 来源： https://blog.csdn.net/weixin_45182641/article/details/113763737
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。