Java基础-java程序基础

hello everyone，here is java world！

java程序基本结构

/*** 可以用来自动创建文档的注释*/
public class Hello {public static void main(String[] args) {// 向屏幕输出文本System.out.println("Hello, world!");/** 可以用来自动创建文档的注释*/}
} // class定义结束

java程序最基本的结构：

class 类名 {}

java对格式没有明确要求，多几个空格或者换行都没有关系，但是会我们要养成良好的编程习惯，遵守java社区约定的编程格式

class Hello {}

我们前面提到的Eclipse的快捷键：Ctrl+Shift+F可以帮助我们快速格式化代码，Eclipse就是按照约定的格式对代码进行格式化的，如果要知道java代码的具体格式要求，可以在Eclipse的设置中找到

因为java是面向对象语言，所以程序的基本单元就是class，class的命名规则需要注意：

类名必须是英文字母、数字、下划线的组合
类名必须以英文首字母开头
要注意遵守命名习惯，好的命名：Hello、NoteBook、VRPlayer
不好的命名：hello（首字母没大写）、Good123（123无实际意义）、Note_Book（带下划线）、_World（下划线开头）

public用来修饰当前类是公开的，不写public也可以正常编译，但是这样无法从命令行执行，在一个class的内部我们可以定义很多方法，方法的定义是由返回值、方法名称、参数构成，方法内部定义的是一组执行语句，方法内部的代码将会被JVM执行

public class 类名 {返回值 方法名 (参数) {}
}

java程序规定的入口程序必须是
`public static void main(String[] args) {
}

方法名也有好的命名和不好的命名，和class一样，但是首字母要小写：

好的命名：main、goodMorning、playVR
不好的命名：Main（首字母大写）、good123（123无实际意义）、good_morning（带下划线）、_playVR（下划线开头）

在方法的括号中间，语句是真正的执行代码，每一句必须以分号结尾

System.out.println(“Hello, world!”);

什么是注释：注释是给人阅读的、编译器会自动忽略注释，java的注释总共有三种：

单行注释：以 // 开头，到当前行尾
多行注释：用 /* … / 表示，以 / 开头，/ 结尾，中间的所有内容都被视为注释
特殊的多行注释：用 /** … / 表示，以 /* 开头，/ 结尾，写在类和方法的定义处，可用于自动创建文档

变量和数据类型

什么是变量

类似于数学的方程式：y = x² + 1，其中y和x都是变量

变量的一个重要特点：可以重新被赋值，我们可以看下面的执行过程

我们可以在Eclipse里用debug模式运行，一步步观察打印结果，当我们点击debug运行，Eclipse会提示我们切换到debug模式，我们点击Yes,并勾选Remember my decision（记住我的决定），这样下次就不会再提示了

java的基本数据类型

整数类型：long、int、short、byte
浮点类型：double、float
布尔类型：boolean
字符类型：char

计算机内存最小的存储单元是位（bit），基本计量单位是字节，一个字节是8位，二进制数：00000000 ~ 11111111（0 ~ 255），内存单元从0开始编号，称为内存地址，一个存储单元相当于一个字节

java类型对应计算机中的字节个数：

byte：8位，1个字节，范围-128~127（-2⁷ ~ 2⁷ - 1）
short：16位，2个字节，范围-32768~32767（-2¹⁵ ~ 2¹⁵ - 1）
int：32位，4个字节，范围（-2³¹ ~ 2³¹ - 1）
long：64位，8个字节，范围（-2⁶³ ~ 2⁶³ - 1），long形整数定义时需要在数字末尾加上 L （小写 l 不推荐使用，容易和数字1混淆），例如：long x = 10L;不加 L 编译默认定义为int类型
float：32位，4个字节，需要在结尾加上 f ，一个浮点类型可以用科学计数法来表示：float f = 3.14e38f（3.14 * 10 ³⁸）
double：64位，8个字节
boolean：1位，1/8个字节，只有两个值，true和false，通常用来比较计算结果，例如：boolean x = 5 >3;
char：16位，2个字节，只能表示一个字符，用单引号表示，例如：char x = ‘中’;
同一个数的不同进制表现是完全不同的：15 = 0xf（16进制） = 0b1111（二进制），为什么将小数称为浮点数，是因为它的小数点是可以浮动的，例如这两个数是相等的：12.34e5 = 1.234e6，我们要区分字符和字符串类型，字符类型用单引号表示，并且只能有一个字符

public class IntType {public static void main(String[] args) {byte b = 127; // -128 ~ +127short s = 32767; // -32768 ~ +32767int i = 2147483647; // -2147483648 ~ +2147483647long l = 9_000_000_000_000_000_000L; // -9223372036854775808 ~// +9223372036854775807System.out.println(b);System.out.println(s);System.out.println(i);System.out.println(l);int i3 = 2_000_000_000;int i4 = 0xff0000; // 十六进制表示的十进制16711680int i5 = 0b1000000000; // 二进制表示的十进制512System.out.println(i3);System.out.println(i4);System.out.println(i5);// 输出十六进制表示的整型：System.out.println(Integer.toHexString(12345678)); // bc614e// 输出二进制表示的整型：System.out.println(Integer.toBinaryString(12345678)); // 101111000110000101001110}}

常量

常量就是用final修饰的变量
常量初始化后不可再次赋值
常量名通常全部大写
常量用来避免意外赋值
常量用来代替Magic Number（魔幻数字，硬编码值，一段时间之后容易忘记代表的含义）

public class Constant {public static void main(String[] args) {final double PI = 3.14;
//      PI = 3.1415;  // 编译报错double r = 4.0;double length = PI * r * 2;double area = PI * r * r;System.out.println(length);System.out.println(area);// magic number:double salary = 12500.0;double pay = salary * (1 - 0.2);
//      final double TAX_RATE = 0.2;
//      double pay = salary * (1 - TAX_RATE);System.out.println(pay);}}

整数运算

运算规则

基于四则运算规则
除法结果为整数
除数为0，运行时会报错，但编译不会报错
java提供了++运算和–运算符，++n或者n++代表n = n + 1，–n或者n–代表n = n - 1，运算符在数字前代表先+1再引用，运算符在数字后代表先引用再+1
java提供了+=和-=运算符，n += 100相当于n = n + 100，n -= 100相当于n = n - 100

public class Div {public static void main(String[] args) {int i = 99 / 9;System.out.println(i);// 整数运算的结果仍然是整数:int n = 100 / 9;System.out.println(n);int z = 100 / 0; // 报错，错误信息会告诉我们错误类型以及具体在哪一行，后面的语句不会执行System.out.println(z);}
}

整数运算需要注意

计算结果溢出不报错，但是计算结果不正确，例如：int x = 2147483647 + 1;计算结果为-2147483648
解决方案：用范围更大的整形进行运算，long x = 2147483647L + 1

移位运算

左移：<<
带符号右移：>>
不带符号右移：>>>
byte和short会先转换为int再进行移位

int n1 = 5;

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	1

int n2 = n1 << 10; // 5120

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	1	0	0	0	0	0	0	0	0	0	0

int n3 = n2 >> 11; // 2，最右边的1超出了范围，所以被丢弃

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0

int n4 = n1 << 29; // -1610612736，最高位表示的是符号位，所以表示的是一个负数

1	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0

int n5 = n4 >> 29; // -3，符号位会被保留

1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	1

int n5 = n4 >>> 29; // 5，符号位不会被保留

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	1

位运算

与运算：&，位上的值都是1才是1，否则为0，1 & 1 = 1; 1 & 0 = 0; 0 & 1 = 0; 0 & 0 = 0;
或运算：|，位上的值有一个1就是1，否则为0，1 | 1 = 1; 1 | 0 = 1; 0 | 1 = 1; 0 | 0 = 0;
异或运算：^，位上的值不相同则为1，相同为0，1 ^ 0 = 1; 0 ^ 1 = 1; 1 ^ 1 = 0; 0 ^ 0 = 0;
非运算：_， 1 = 0，~ 0 = 1；

int n1 = 0x03_83_d0_25;

0	0	0	0	0	0	1	1	1	0	0	0	0	0	1	1	1	1	0	1	0	0	0	0	0	0	1	0	0	1	0	1

int n2 = 0x00_00_ff_ff;

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1

int n3 = n1 & n2; // 53285, 0x00_00_d0_25

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	0	1	0	0	0	0	0	0	1	0	0	1	0	1

int n4 = n1 | n2; // 0x03_83_ff_ff

0	0	0	0	0	0	1	1	1	0	0	0	0	0	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1

运算优先级

由高到低：

1.~ ++ --
2.* / %
3.+ -
4.<< >>
5.&
6.|

一般我们很难记住这些运算符的优先级，所以可以使用括号()来明确执行顺序

类型自动提升与强制转型

在运算过程中，计算结果为较大类型的整形
short s = 12; int i = 100 + s; long n = 999 * i;
可以将结果强制转型，（类型）变量或数值
int y1 = (int) (n - 199); int y2 = (int) n - 199;
强制转型可能会丢失精度，当超过最大位数，会将高位全部抛弃
int z = (int) (n * 100000000)

我们要选择合适的类型进行运算，没有必要为了节省内存使用byte或short，因为它们表示的范围太小

浮点数运算

浮点数的特点

很多浮点数无法精确表示，例如：double a = 0.1;二进制表示：0.0 0011 0011 0011…，这是一个无限小数，计算机不可能在有限的内存中表示一个无限的小数
计算有误差：double b = 1 - 9/10; 理论上结果应该是0.1，但是因为浮点数无法精确表示，所以在计算过程中会有误差
整形可以自动提升到浮点形：double d1 = 1.2 + 24.0/5; 结果是6.0
特别注意，类型不能自动提升的情况：double d1 = 1.2 + 24/5; 结果是5.2

public class FloatOps {public static void main(String[] args) {double a = 0.1;double b = 1 - 9.0 / 10;System.out.println(a); // 0.1System.out.println(b); // 0.09999999999999998// 注意没有自动提升的情况:double d1 = 1.2 + 24.0 / 5; // 6.0double d2 = 1.2 + 24 / 5; // 5.2System.out.println(d1);System.out.println(d2);}
}

浮点数计算有几个特殊值需要注意：

NaN：Not a Number
Infinity：无穷大
-Infinity：负无穷大

public class NaN {public static void main(String[] args) {double d1 = 0.0 / 0; // NaNdouble d2 = 1.0 / 0; // Infinitydouble d3 = -1.0 / 0; // -InfinitySystem.out.println(d1);System.out.println(d2);System.out.println(d3);}
}

强制转型

强制转为整形会直接扔掉小数位
四舍五入的技巧
超出整形范围会自动变为最大值

public class ToInt {public static void main(String[] args) {int n1 = (int) 12.3; // 12int n2 = (int) 12.7; // 12int n3 = (int) (12.7 + 0.5); // 13int n4 = (int) 1.2e20; // 2147483647System.out.println(n1);System.out.println(n2);System.out.println(n3);System.out.println(n4);}
}

布尔运算

布尔运算的运算符

关系运算：< ，<=，>，>=，==，!=
与运算：&&
或运算：||
非运算：!

短路运算符

与运算：&&，参与运算的操作数只要有一个是false那么就是false，所以确定为false后，后面的运算操作将不再进行运算，例如：boolean and = false && (5 / 0 > 0); // false
或运算：||，参与运算的操作数只要有一个是false那么就是true，所以确定为true后，后面的运算操作将不再进行运算，例如：boolean or = true || (5 / 0 > 0); // true
因为短路运算符的规则，(5 / 0 > 0)将不会运行，否则程序将会报错

三元运算符

根据条件b计算x或y：b ? x : y
x和y只计算其中一个
x和y类型必须相同

字符和字符串

字符类型

字符类型是基本数据类型，一个char类型保存一个字符，他可以保存一个英文字符，也可以保存一个中文字符

java使用Unicode编码来表示字符，我们要看一个char类型的Unicode编码，可以直接将一个char类型赋值给int类型，这个int类型的值就是Unicode编码，例如：
int x = 'A'; // 65
int y = '中'; // 20013
我们也可以直接用Unicode编码来表示，方法是用\u + 4位16进制数表示：
char x = '\u0041'; // 'A'
char y = '\u4e2d'; // '中'

字符串类型

字符串类型不是一个基本类型，它是引用类型
字符串类型String，表示一个字符串，字符串内容用双引号表示，字符串内容并不包含开头结尾的两个双引号
转移字符：
如果我们需要表示一些特殊字符，我们就需要用到转移字符，常用的转移字符：\n，"，\r，\t，\

字符串操作

字符串最常用的操作是字符串连接，用+连接，我们可以连接两个字符串也可以将字符串和其他类型进行连接，例如：
String x = "hello" + ",world!"； String y = "age is " + 12;

理解引用类型

字符串是引用类型，字符串是不可变的
引用类型特点：变量指向某个对象，而不是持有某个对象
所有的应用类型都可以指向一个特殊的值：null（空值），当我们给一个引用变量赋值为null，我们可以认为当前变量不指向任何对象，但是空值null和空字符串是不一样的，空字符串也是一个对象，例如：
String s = null;
System.out.println(s); // null
String t = "";
System.out.println(t);

总结

区分字符类型（基本类型）和字符串类型（引用类型）
基本类型的变量是持有某个数值
引用类型的变量是指向某个对象
引用类型的变量可以是null
区分空（null）和空字符串（""）

数组类型

什么是数组类型

当有一组类型相同的变量时，可以用数组表示

数组类型是"类型[]"，数组初始化用 new 类型[长度]，例如：int[] ns = new int[5]; 也可以直接指定初始化元素，由编译器自动为我们推算出数组的大小，例如：int[] ns = new int[] {68, 79, 91, 85, 61}; 还可以进一步简写，例如：int[] ns = {68, 79, 91, 85, 61};
数组初始化所有元素为默认值，对于int数组默认值全部都是0
数组创建后大小不可变，即数组长度不可变，但数组变量是可以指向另一个数组对象
数组索引从0开始
可以用 数组变量.length 获取数组长度
数组是一种引用类型的变量
使用索引（下标）访问数组元素，索引超出范围将报错

public class Hello {public static void main(String[] args) {// 5位同学的成绩int n1 = 68;int n2 = 79;int n3 = 91;int n4 = 85;int n5 = 61;int[] ns = new int[5];ns[0] = 68;ns[1] = 79;ns[2] = 91;ns[3] = 85;ns[4] = 61;System.out.println(ns.length); // 5System.out.println(ns[2]); // 91System.out.println(ns[5]); // Error!ns = new int[] {1, 2, 3}; // 这是可行的，数组本身没有变，只是ns变量从一个数组对象指向另一个数组对象，数组本身是没有变的，它只是创建了一个新的数组对象String[] names = {"xiaoming", "xiaohong", "xiaojun"}; // 字符串数组的每一个元素都指向一个字符串对象names[2] = "daniu"; // 将原来数组2号位的指向从xiaojun指向了新的字符串daniu}
}

public class Main {public static void main(String[] args) {int[] ns1 = new int[5]; // { 0, 0, 0, 0, 0 }int[] ns2 = new int[] { 1, 3, 5, 7, 9 };int[] ns3 = { 2, 4, 6, 8, 10 };int[] ns4 = ns3;System.out.println("ns1.length: " + ns1.length);System.out.println("ns2.length: " + ns2.length);System.out.println("ns3.length: " + ns3.length);// 现在ns3和ns4指向同一个数组:System.out.println("ns3[1]: " + ns3[1]);ns3[1] = 999;System.out.println("ns4[1]: " + ns4[1]);// 把ns3指向一个新数组:ns3 = new int[] { 1, 2, 3 };ns3[1] = 888;System.out.println("ns4[1]: " + ns4[1]);// String数组:String[] strs = { "Abc", "Xyz", "123" };strs[1] = "Hello";}
}
打印结果：
ns1.length: 5
ns2.length: 5
ns3.length: 5
ns3[1]: 4
ns4[1]: 999
ns4[1]: 999

总结

数组是同一数据类型的集合
数组是引用类型
数组元素是值类型（如int[]）或引用类型（如String[]）
数组一旦创建大小不可变
可以通过索引访问数组元素
索引超出范围将报错

Java基础-程序基础相关推荐

1. shadowplay要下载java_Java并发程序设计（二）Java并行程序基础

   Java并行程序基础 一.线程的生命周期 其中blocked和waiting的区别: 作者:赵老师 链接:https://www.zhihu.com/question/27654579/answer/ ...

2. Java并发程序设计（二）Java并行程序基础

   Java并行程序基础 一.线程的生命周期 其中blocked和waiting的区别: 作者:赵老师 链接:https://www.zhihu.com/question/27654579/answer/ ...

3. （二）Java并行程序基础

   Java并行程序基础 2.1 线程和进程 2.2 初始线程 2.2.1 新建线程 2.2.2 线程中断 2.2.3 等待(wait)和通知(notify) 2.2.4 挂起(suspend)和继续执行 ...

4. Java面向对象程序基础设计之第三章

   3.1.1 自定义包 如果在程序中没有声明包,类将被存放在default的包中,该方式不被提倡. 语法: package 包名 包命名规范: 包的命名规范应当体现出项目资源良好的划分 自定义标签类所在 ...

5. java面向对象程序基础实验_20165115 实验二《Java面向对象程序设计》实验报告

   20165115 实验二 面向对象程序设计 这一次的实验,老师按照实验内容的不同将实验分成了五个部分进行.五个部分的侧重难易都有区别,实验报告中的叙述也会有所区别. 第一部分 先上实验结果截图: 这一 ...

6. Java并行程序基础

   有关线程 进程是计算机中的程序关于某数据集合上的一次运动活动,是系统进行资源分配的基础单位.进程是线程的容器.程序是指令.数据及其组织形式的描述,进程是程序的实体. 线程的生命周期 线程的所有状态都在 ...

7. Java并行程序基础（十二）

   2019独角兽企业重金招聘Python工程师标准>>> 无锁 对于并发控制而言,锁是一种悲观策略.它总是假设每一次的临界区操作会产生冲突,因此,必须对每次操作都小心翼翼.如果多个线程 ...

8. Spring Boot –现代Java应用程序的基础

   Spring Boot是Spring.io中一个相对较新的项目. 其目的是简化创建新的基于Spring Framework的项目,并通过应用一些约定来统一其配置. 这种关于配置的方法约定已经成功地应用 ...

9. java负数右移_收入囊中篇---Java程序基础（二）

   前言: 本篇是接着上一篇更新的,如果没有阅读上一篇的话,可以查阅或回顾一下. 1.收入囊中篇---Java基础必备知识(一) 2.收入囊中篇---Java程序基础(二) Java程序基础目录 1.Ja ...

最新文章

1. 基于Metronic的Bootstrap开发框架经验总结（7）--数据的导入、导出及附件的查看处理...
2. 实现php实现价格的排序,PHP实现二维数组排序(按照数组中的某个字段)
3. ONOS项目首赢11000次下载 Oracle发布云路由
4. python语言用途-Python是万能的编程语言吗?这五大用途很重要!
5. Linux下Console的分类与切换
6. python 3.9特性,Python 3.9 正式版要来了，会有哪些新特性？
7. 页面添加复制代码功能
8. xmlHttpRequest无刷新验证用户名
9. NDPQ(NDP+PQ)，定义分布式数据库新方向
10. 【华为云技术分享】Scrum Master如何引导团队中的刺头
11. 扫盲了,RC,RTM,Beta等各个版本的意思
12. 雷军：疫情影响了小米的生产 正加快小米10系列供货
13. android textwatcher 获取当前控件,TextWatcher如何找到调用它的EditText
14. 大学C语言学习笔记（C语言程序设计第五版——谭浩强，翁凯C语言基础教程）基础、算法、程序结构、数组、函数、指针、枚举、结构、联合
15. 科研笔记(六) 基于环境感知的室内路径规划方法
16. git push 报错 error: failed to push some refs to ‘git@xxx/xx.git‘
17. java调用打印机没反应_java调用打印机问题
18. mSystem：鸟枪法宏基因组测序之外我们还能做什么
19. 戴尔电脑如何设置快速开机
20. Linux 安装Redis 图解教程

热门文章

1. IT新人到底该不该去外包公司？
2. excel表格分割线一分为二_Anki+思维导图的两种方法（Anki+表格，Anki+幕布）
3. 【官方】Mysql中注释的规范写法（全部）
4. Unity后处理效果之边角压暗
5. 超全！182所大学的考研复试参考书目/复试通知
6. CodeForces 954D-Fight Against Traffic（加边最短路）
7. 二、Git本地仓库基本操作——创建Git仓库、提交更新或删除文件
8. 盒子模型属性详解及案例
9. python操作Excel的5种常用方式
10. 【报告分享】2021中国消费者洞察-埃森哲（附下载）