JAVA 学习 - Java 的基本程序设计结构

因公司 python 项目结束,暂时也没有 python 的项目,所有需要我们 python 小组的人去转到 Java 项目组,给了一段时间学习,公司的全栈工程师大佬给我们安排了学习计划,给了基本 Java 的电子书,开始一段时间的带薪学习,顺便在这里发一下学习的笔记。
公司目前其他两个 Java 项目的架构都是使用 spring boot 加 spring cloud 微服务架构,这个目前也只是听听,没有具体的概念,往后学就知道了。

学习计划安排

  • Java 基础和 Java 高级跟着《Java 核心编程第 10 版这本书进行学习》
  • servlet(Jsp)
  • spring
  • spring boot
  • spring cloud

JAVA 核心编程第 10 版 第三章 Java 的基本程序设计结构

注释

注释有三种方式

// 常用单行注释  类似于 python 的 # 

/*
多段注释,类似于 python 的 """

"""
*/

/**
多段注释,用于自动生成文档

*/

3.3 数据类型

3.3.1 整型

整型用于表示没有小数部分的数值, 它允许是负数。Java 提供了 4 种整型,

类型 存储需求 取值范围
int 4字节 -2 147 483 648 - 2 147 483 647 (正好超过 20 亿)
short 2字节 -32 768 - 32 767
long 8字节 -9 223 372 036 854 775 B08 - 9 223 372 036 854 775 807
byte 1字节 -128 ~ 127

一般使用 int,长的值使用 long,特殊情况使用 short,byte

3.3.2 浮点类型

浮点类型用于表示有小数部分的数值。在 Java 中有两种浮点类型,

一般使用 double 类型,因为 float一般满足不了精度

类型 存储需求 取值范围
float 4字节 大约 ± 3.402 823 47E+38F (有效位数为 6 ~ 7 位)
double 8字节 大约 ± 1.797 693 134 862 315 70E+308 (有效位数为 15 位)
  • double 表示这种类型的数值精度是 float 类型的两倍(有人称之为双精度数值)。绝大部分应用程序都采用 double 类型。在很多情况下,float 类型的精度很难满足需求。实际上,只有很少的情况适合使用 float 类型,例如,需要单精度数据的库, 或者需要存储大量数据。
  • float 类型的数值有一个后缀 Ff (例如,3.14F。) 没有后缀 F 的浮点数值(如 3.14 ) 默认为 double 类型。当然,也可以在浮点数值后面添加后缀 Dd (例如,3.14D) 。
  • NaN 不是一个数字,判断的时候需要注意。
  • 金额计算不要使用浮点数,使用特殊的类 BigDecimal

3.3.3 char 类型

char 类型基本上用于表示单个字符。现在和 Unicode 有一些交互

特殊字符的专业序列
转义序列 名称 Unicode 值
\b 退格 \u0008
\t 制表 \u0009
\n 换行 \u000a
\r 回车 \u000d
\" 双引号 \u0022
\’ 单引号 \u0027
\\ 反斜杠 \u005c

3.3.4 Unicode 和 char类型

UTF - 16

3.3.5 boolean类型

boolean(布尔)类型有两个值:false 和 true,用来判定逻辑条件。整型值和布尔值之间不能进行转换。



3.4 变量

在Java 中,每个变量的都有一个类型(type)。在声明变量时,变量的类型位于变量名之前。

示例:

double salary;
int vacationDays;
long earthPopulation;
boolean done;

// 每个声明以分号结束。

由于声明是一条完整的 Java 语句,所以必须以分号结束。

Java 语句需要以分号 ; 结束。

  • 变量名必须是一个以字母开头并由字母或数据构成的序列;

  • 需要注意,与大多数程序设计语言相比,Java 中的 “字母” 和 “数字” 的范围更大;

  • 字母包括 ’ A’ ~ ’ Z’、 ’ a’ ~ ‘z’、‘_’、‘$’ 或在某种语言中表示字母的任何 Unicode 字符;

  • 变量名中所有的字符都是有意义的,并且大小写敏感;

  • 变量名的长度基本上没有限制;

  • 不能使用 Java 保留字作为变量名;

  • 可以在一行中声明多个变量:

    int i,j; 
    

    不提倡使用这种风格,逐一声明每一个变量可以提高程序的可读性。

3.4.1 变量初始化

  • 声明一个变量之后,必须用赋值语句对变量进行显式初始化,千万不要使用未初始化的变量。

    // 例如, Java 编译器认为下面的语句序列是错误的:
    int vacationDays;
    System.out.println(vacationDays): // ERROR variable not initialized
    
  • 要想对一个已经声明过的变量进行赋值, 就需要将变量名放在等号(=) 左侧, 相应取值 的 Java 表达式放在等号的右侧。

    int vacationDays; 
    vacationDays:12; 
    

    也可以将变量的声明和初始化放在同一行中。例如:

    int vacationDays = 12; 
    
  • 最后,在 Java 中可以将声明放在代码中的任何地方。例如,下列代码的书写形式在 Java 中是完全合法的:

    double salary = 65000.0; 
    System,out.println(salary); 
    int vacationDays = 12; // OK to declare a variable here 
    

    在 Java 中, 变量的声明尽可能地靠近变量第一次使用的地方, 这是一种良好的程序编写风格。

3.4.2 常量

  • 在 Java 中, 利用关键字 final 指示常量;
  • 关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后,就不能够再更改了;
  • 习惯上, 常量名使用全大写;
  • Java 中,经常希望某个常量可以在一个类中的多个方法中使用,通常将这些常量称为 类常量。可以使用关键字 static final设置一个类常量;
  • 常量被声明为 public,那么其他类的方法也可以使用这个常量;



3.5 运算符

  • +、-、*、/ 表示加、减、乘、除;

  • 除法运算 / 时,两个操作数都是整数时,表示整数除法;否则表示浮点除法;

  • 整除的求余操作(取模)用 % 号表示;

  • // demo
    15 / 2 等于 7
    15 % 2 等于 1
    15.0 / 2  等于 7.5
    
  • 注意:整数被 0 除 将会产生一个异常,而浮点数被 0 除将会得到无穷大或 NaN 结果

3.5.1 数学函数与常量

Java 里面提供的 Math 类来进行一些数学计算;

在 Math类中,包含了各种各样的数学函数。在编写不同类别的程序时,可能需要的函 数也不同。

// 不必在数学方法名和常量名前添加前缀“ Math”, 只要在源文件的顶部加上下面这行代码就可以了。
import static java.1ang.Math.*;

// sqrt 方法
// 要想计算一个数值的平方根, 可以使用 sqrt 方法:
double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // prints 2.0

// pow 方法
// 在 Java中,没有幂运算, 因此需要借助于 Math 类的 pow 方法。语句:
double y = Math.pow(x, a);
// 将 y 的值设置为 x 的 a 次幂( xa)。pow 方法有两个 double 类型的参数, 其返回结果也为double 类型

// floorMod 方法
// floorMod 方法的目的是解决一个长期存在的有关整数余数的问题。
floorMod(position + adjustment, 12)
// 总会得到一个 0 ~ 11 之间的数。

// Math 类提供了一些常用的三角函数:
Math,sin
Math.cos
Math.tan
Math.atan
Math.atan2

// 还有指数函数以及它的反函数—自然对数以及以 10 为底的对数:
Math.exp
Math.log
Math.loglO

// 最后 Java 还提供了两个用于表示 TC 和 e 常量的近似值:
Math.PI
Math.E

3.5.2 数值类型之间的转换

经常需要将一种数值类型转换为另一种数值类型。

在图中有 6 个实心箭头,表示无信息丢失的转换;有 3 个虚箭头, 表示可能有精度 损失的转换。 例如,123 456 789 是一个大整数, 它所包含的位数比 float 类型所能够表达的 位数多。 当将这个整型数值转换为 float 类型时, 将会得到同样大小的结果,但却失去了一定 的精度。

int n = 123456789; 
float  = n; // f is 1.23456792E8 

当使用上面两个数值进行二元操作时(例如 n + fn 是整数, f 是浮点数,) 先要将两个操作数转换为同一种类型,然后再进行计算。

  • 如果两个操作数中有一个是 double 类型, 另一个操作数就会转换为 double 类型。
  • 否则,如果其中一个操作数是 float 类型,另一个操作数将会转换为 float 类型。
  • 否则, 如果其中一个操作数是 long 类型, 另一个操作数将会转换为 long 类型。
  • 否则, 两个操作数都将被转换为 int 类型。

3.5.3 强制类型转换

double x = 9.997;
int nx = (int) x;
// nx = 9

// round 取最接近的整数
double x = 9.997;
int nx = (int) Math.round(x);
// nx = 10

3.5.4 结合赋值和运算符

x += 4 // 相当于 x = x + 4

3.5.5 自增与自减运算符

n++ // 将当前变量加 1
n-- // 将当前变量减 1

// ++ 的位置影响运算
int m = 7;
int n = 7;
int a = 2 * ++m; // now a is 16, m is 8
int b = 2 * n++; // now b is 14, n is 8

3.5.6 关系和 Boolean 运算符

  • Java 判等使用 ==

  • 不等 !=

  • < (小于)、 > (大于)、<=(小于等于)和 >= (大于等于)

  • &&(与)、||(或)、!(非)

  • 三元操作符 ?

    x < y ? x : y
    // 会返回 x 和 y 中较小的一个。
    

3.5.7 位运算符

// 位运算符包括:
& ("and") | ("or") A ("xor") ~ ("not") 
   
// 还有 >> 和 << 运算符将位模式左移或右移

3.5.8 括号与运算符级别

  • 如果不使用圆括号, 就按照给出的运算符优先级次序进 行计算。
  • 同一个级别的运算符按照从左到右的次序进行计算(除了表中给出的右结合运算符外).
// 例如,由于 && 的优先级比 || 的优先级高, 所以表达式
a && b || c
// 等价于
// (a && b) || c

// 又因为 += 是右结合运算符, 所以表达式
a += b += c
// 等价于
a += (b += c)
// 也就是将 b += c 的结果(加上 c 之后的 b) 加到 a 上。
运算符优先级

3.5.9 枚举类型

// 在变量中很可能保存的是一个错误的值(如 0 或 m)。
// 针对这种情况, 可以自定义枚举类型。枚举类型包括有限个命名的值。 例如,
enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARCE };
// 现在,可以声明这种类型的变量:
Size s = Size.MEDIUM
// Size 类型的变量只能存储这个类型声明中给定的某个枚举值,或者 null 值,null 表示这个变量没有设置任何值。



3.6 字符串

3.6.1 子串

// String 类的 substring 方法可以从一个较大的字符串提取出一个子串。例如:
String greeting = "Hello";
String s = greeting.substring(0, 3);
//创建了一个由字符“ Hel” 组成的字符串。

// 相当于 python 里面使用索引的方式来切割字符串

3.6.2 拼接

拼接方式和 python 一样,使用 + 号进行拼接即可

3.6.3 不可变字符串

String 类没有提供用于修改字符串的方法

// 先取出然后再拼接,实现字符串修改想·
greeting = greeting.substring(0, 3) + "p!";

3.6.4 检测字符串是否相等

可以使用 equals 方法检测两个字符串是否相等。对于表达式:

s.equals(t)

要想检测两个字符串是否相等,而不区分大小写, 可以使用 equalsIgnoreCase 方法。

“Hello”.equalsIgnoreCase(“hel1o”)

一定不要使用=运算符检测两个字符串是否相等! 这个运算符只能够确定两个字串是否放置在同一个位置上。当然, 如果字符串放置在同一个位置上, 它们必然相等。但是, 完全有可能将内容相同的多个字符串的拷贝放置在不同的位置上。



3.7 输入输出

3.7.1 读取输入

// 首先需要构造一个 Scanner 对象,并与“ 标准输人流” System.in 关联
Scanner in = new Scanner(System.in);
System.out.print("What is your name? ");
String name = in.nextLine();
// get second input
System.out.print("How old are you? ");
int age = in.nextInt();

// display output on console
System.out.println("Hello, " + name + ".Next year, you'll be" + (age + 1));

3.7.2 格式化输出

double x = 10000.0 / 3.0;
System.out.print(x);

System.out.printf("%8.2f", x);

在这里插入图片描述

3.8 控制流程:

块作用域:变量的使用区域

if 判断、for 循环、while 循环:这三个类似于 python;break、continue 用于结束循环

switch 语句:一种逻辑判断方式,一般不使用



3.9 大数值操作:

如果基本的整数和浮点数精度不能够满足需求, 那么可以使用jaVa.math 包中的两个很有用的类:Biglnteger 和 BigDecimaL 这两个类可以处理包含任意长度数字序列的数值。

Biglnteger 类实现了任意精度的整数运算, BigDecimal 实现了任意精度的浮点数运算。

Biglnteger 和 BigDecimal, Java 中的大数值操作需要使用这两个类



3.10 数组

数组是一种数据结构, 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。

类似于 python 中的列表,操作方式有些不一样,感觉没有 python 中的方便;

在声明数组变量时, 需要指出数组类型 ( 数据元素类型紧跟 []) 和数组变量的名字。下

面声明了整型数组 a:

int[] a; 

不过, 这条语句只声明了变量 a, 并没有将 a 初始化为一个真正的数组。应该使用 new 运算

符创建数组。

int[] a = new int[100];

这条语句创建了一个可以存储 100 个整数的数组。数组长度不要求是常量: newint[n] 会创建

一个长度为 n 的数组。

数组赋值:

int[] a = new int[100];
for (int i = 0; i < 100; i++)
    a[i] = i; // fills the array with numbers 0 to 99

匿名数组

int[] smallPrimes = { 2, 3, 5, 7, 11, 13 };
// 匿名数组
smallPrimes = new int[] { 17, 19, 23, 29, 31, 37 };
int[] anonymous = { 17, 19, 23, 29, 31, 37 };
smallPrimes = anonymous;

数组拷贝

// 数组拷贝
int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

// Arrays 类的 copyOf方法:   这个方法通常用来增加数组的大小
//int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers , luckyNumbers .length);
luckyNumbers = Arrays.copyOf(luckyNumbers , 2 * luckyNumbers.length);

数组排序

 // 数组排序  sort 方法
int[] a = new int[10000];
Arrays.sort(a);

多维数组

相当于 python 列表的嵌套,注意构建方式

// 多维数组
int[][] magicSquare = {
    {16, 3, 2, 13},
    {5, 10, 11, 8},
    {9, 6, 7, 12}, 
    {4, 15, 14, 1}
};
发布了97 篇原创文章 · 获赞 57 · 访问量 3万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览