Java知识总结

浮点数关系操作符陷阱

“陷阱”来自浮点数的精度误差，尤其是使用==操作符的时候。

System.out.print(0.99999999999999999==1.0);

输出：true

可以看出，逻辑上本来不相等的两个小数使用==操作符比较后，得到了true（意味着相等）的结果。所以，在编程的过程中，一定要小心类似的情况。

BMI指标

（生活常识积累罢了）

BMI 又叫身体健康指数, 针对 20 岁及以上的人群, 是根据其身高(米)和体重(千克)计算出一个数值, 依此数值来衡量身体健康状况。其计算方式如下:

BMI=weight/height的2次方

其中height是身高(米), weight是体重(千克)。

身体状况判断标准

根据 BMI 指标， 我们可以按照如下表格来判断身体状况：

BMI	说明
BMI<18.5	偏瘦
18.5<=BMI<25.0	正常
25.0<=BMI<30.0	超重
30.0<=BMI	过胖

cramer 规则

 2 元线性方程组求解的方法： cramer 规则： 对于 2×2 线性方程：

ax+by=e，cx+dy=f

根据 cramer 规则，其解为：

x=（ad−bc）/（ed−bf）​,  y=（ad−bc）/（af−ec）​

当 ad−bc=0 时，无解。

switch 语句

满足以下规则：

• switch 表达式必须用小括号包围，并且能计算出char，byte，short，int或者String类型的值；
• case 后的值不能包含变量；
• default 是可选的，当没有 case 与 switch 语句匹配时， 执行该操作；
• break 语句是可选的，当执行到 break 时，立即终止 switch 语句。

ASCII 码

需要注意的是， ASCII 码在计算机中用 8 bit 表示，只能表示 128 个字符，码的范围从 0 到 127。

简言之，就是用一个字节（8 bit，对应十进制范围 0（全零） 到 127（全一））来表示 128 个字符。 例如，字母表中的 A，其 ASCII 码是 65（十进制），然后 B 是 66。还有小写的 a，其 ASCII 码是 97。

ceil、floor和round的功能

首先，这三个方法都是Math类的静态方法，而且类Math在java.lang包下，所以我们在代码中可以直接调用Math的方法。

Math.ceil(double a)实现的是对小数向右取整，如 Math.ceil(-0.7) = -0.0，Math.ceil(0.5) = 1.0， Math.ceil(1.3) = 2.0

Math.floor(double a)实现的是对小数向左取整，如 Math.floor(-0.7) = -1.0，Math.floor(0.5) = 0.0， Math.floor(1.3) = 1.0

Math.round(double a)实现的逻辑是四舍五入，但是对于负数有点不一样，如 Math.round(-1.5) = -1，Math.round(-0.5) = 0，有点绕，所以为了好记点，等效为 Math.floor(a+0.5)，而且返回的是整数。
原文链接：https://blog.csdn.net/yldmkx/article/details/109404540

Scanner input = new Scanner(System.in);
// 输入字符串
String numStr = input.nextLine();
// 判断正整数
if(!isNumeric(numStr)){
    System.out.println("no");
} else {
    System.out.println("yes");
}

   public static boolean isNumeric(String str) {
        if (str.length() == 0) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        int i = Integer.parseInt(str);
        if(i<=0){
            return false;
        }
        return true;
    }

printf使用

Java中的printf()方法_java printf_苗半里的博客-CSDN博客

为了完成本关任务，你需要掌握：Java 访问控制修饰符的使用。

Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

访问控制符是一组限定类、属性或方法是否可以被程序里的其他部分访问和调用的修饰符。类的访问控制符只能是空或者 public，方法和属性的访问控制符有 4 个，分别是 public、 private、protected 和 default，其中 default 是一种没有定义专门的访问控制符的默认情况。

我们可以通过下表来说明访问权限：

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N（说明）	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

访问控制存在的原因：

1. 让客户端程序员无法触及他们不应该触及的部分；
2. 允许库设计者改变类内部的工作方式而不用担心会影响到客户端程序员。

default

如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问和引用，而不能被其他包中的类使用。

例如：

Demo 类现在使用的是默认控制符，并且它在 com.test 包中。

package com.test
class Demo {

}

Person 类也处于 com.test 包中。

package com.test
import com.test.Demo;

class Person {
Demo d;
}

上面的这两个类都处于同一个包中，它们被默认控制符所修饰，所以两个类可以相互访问。而假如 Demo 类处于 com 包中，则它们就不能互相访问。

public

共有的，是访问权限限制最宽的修饰符。被 public 修饰的类、属性、及方法不仅可以跨类访问，而且可以跨包访问。 例如：

public static void main(String[] args) {
}

我们之前所定义的主方法不管在哪个类中，哪个包中，都可以被访问。

private

用 private 修饰的类成员、属性以及方法只能被该类的对象访问，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

例如：

public class Person {
private String name;
private int age;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

实例中，Person 类中的 age 和 name 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个变量的 get 和 set 方法，用来获取变量的值和设置变量的值。

public class Demo {
public static void main(String[] args) {
Person person = new Person();
person.setAge(18);
person.setName("张三");
System.out.printf("我的名字叫%s，今年%d岁",person.getName(),person.getAge());
}
}

执行结果：我的名字叫张三，今年18岁

protected

用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。

类

类： 类就是具备某些共同特征的实体的集合，它是一种抽象的数据类型（它属于引用数据类型），它是对所具有相同特征实体的抽象。

对象：是类的一个实例，有状态和行为。每个对象拥有自己独立的属性，依靠属性来区分不同对象。

在面向对象的程序设计语言中，类是对一类“事物”的属性与行为的抽象。属性是事物的状态，行为就是这个事物可以做什么。比如，人就是一个类，那么具体的某个人“小明”就是“人”这个类的对象，而“体重、性别、年龄”等信息就是对象的属性，人的行为比如“吃饭、睡觉和玩”等就是对象的方法。

注意：类只是一个抽象的概念，它仅仅是一个概念，是不存在的实体！

类的声明

在 Java 中定义类，使用关键字 class 完成。语法如下：

权限修饰符 class 类名称 {
属性 (成员变量) ;
行为 (成员方法（函数）) ;
}

权限修饰符可写可不写，我们之前见到的 public 就是权限修饰符的一种。

例子：声明一个人类。

public class Person {
// 属性 (成员变量) ;
// 行为 (成员方法（函数）) ;
}

public 表示“共有”的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类。

创建一个新的类，就是创建一个新的数据类型。定义类其实就是在定义类中的成员（成员变量和成员函数）。

变量

在 Java 中类的成员变量定义了类的属性。例如，一个人类中一般有体重、性别和年龄等属性，这时就需要定义体重、性别和年龄 3 个属性。

那 Java 中的成员变量又是什么呢？

首先我们来看，Java 语言支持的变量类型有：

• 局部变量：在类的方法中定义的变量，且只能在该方法中使用，我们之前学习的变量都是局部变量；定义以后必须赋值才能使用；

• 成员变量：也称为实例变量，它的定义在方法的外部，直接写在类当中；随着对象创建而诞生，随着对象被垃圾回收而消失；如果是对某个对象的特殊描述，可以用该变量；定义时如果不赋值的话，会采用默认初始值；

• 静态变量：也称为类变量，实质上是一个全局变量。它的定义在方法的外部，直接写在类当中，与类共存亡，它用 static 修饰，如果某个内容是被所有对象所共享，那么该内容就应该用 static 修饰；定义时如果不赋值的话，会采用默认初始值。

例子：

public class Demo {
static int a; // 类变量
int b; // 实例变量
public static void main(String[] args) {
int c; // 局部变量
}
}

我们再来看一下它们是如何被引用的：

• 局部变量可以直接在方法中赋值或引用，就像我们之前学习的一样；
• 成员变量必须得通过创建一个对象后引用；
• 类变量在这个类中可以直接拿来用，若是在另一个类中要用到该类的类变量，需要通过类名.变量名引用。

现在我们对成员变量已经有了一定的了解，接下来看个例子吧。

在 Person 类中定义该类的成员变量，也就是该类的属性。

public class Person {
// 属性 (成员变量) ;
double weight ; // 为该类定义一个表示体重的成员变量
char sex; // 为该类定义一个表示性别的成员变量
int age; // 为该类定义一个表示年龄的成员变量
}

成员方法

在 Java 中类的成员方法定义了类的行为。例如，一般人会有吃饭、睡觉和玩等行为，在定义人的类时，就需要定义吃饭、睡觉和玩 3 个方法。

类的各种功能操作都是用方法来实现的，属性只不过提供了相应的数据。一个完整的方法通常包括方法名称、方法主体、方法参数和方法返回值类型。

成员方法的声明语法：

[权限修饰符]　返回值类型　方法名（[参数类型　参数名]） {
// 方法体
// 返回值
}

注意：[ ] 表示可写可不写。

返回值类型：我们之前学到的八种基本类型和 void 都可以用来做方法的返回值类型。要注意的是 void 表示没有返回值，所以不需要写返回值语句，而其他类型都需要返回一个该类型的值。

返回值语句：

return 返回值;

参数类型 参数名：可以有多个，这些参数都要有自己的数据类型，可以是原始数据类型，也可以是复杂数据类型，一个方法主要依靠参数来传递消息。方法主体是方法中执行功能操作的语句。

例子：

public int a(){ // 定义一个名为a，返回值类型为int的成员方法
// 返回值语句： return 返回值;
return 0; // 由于返回值类型为 int，所以需要返回一个int型的常量或变量
}
public void c(){ // 定义一个成员方法，它的名为c，返回值类型为void，该方法不需要返回值。
}

以上是没有携带参数的，那携带参数的又是怎么回事呢？

例子：

public double b(int a,double b){ // 定义一个名为c，返回值类型为double的成员方法，其携带的参数有两个，一个为int型的变量a，一个double型的变量b
double c = a*b;
return c; // 由于返回值类型为 int，所以需要返回一个int型的常量或变量
}

成员方法的调用必须通过实例一个对象来调用。

同样方法也可以被 static 修饰，变为静态方法，只不过变为静态方法以后，就不能调用实例变量，而成员方法却可以调用静态变量。如果在该类中调用静态方法的话，我们可以直接调用，而如果不在同一个类中，需要通过类名.方法名()或者实例一个对象，通过该对象调用静态方法。

例子：在人的类中定义它的成员方法（行为）。

public class Person {
// 属性 (成员变量) ;
double weight = 100.00; // 为该类定义一个表示体重的成员变量
char sex = '男'; // 为该类定义一个表示性别的成员变量
int age = 18; // 为该类定义一个表示年龄的成员变量
// 定义一个名为a，返回值类型为int的成员方法
public void eat(){ // 该成员方法表示吃饭这个行为
System.out.printf("我喜欢吃饭，所以我的体重高达%f千克\n",weight);
}
// 定义一个名为a，返回值类型为int的成员方法
public void sleep(){ // 该成员方法表示睡觉这个行为
System.out.println("我正在睡觉！");
}
public void play(){ // 该成员方法表示玩这个行为
System.out.printf("我的性别为%c，今年%d岁，我喜欢玩耍",sex,age);
}
}