java笔记

第一天：安装JAVA环境

打开网址：https://www.azul.com/downloads/?version=java-8-lts&os=windows&package=jdk#zulu

选择JDK下载

安装

执行java -version

 代表安装完成

 执行java程序

输入CMD

 编译程序javac

 

编译完生成clss文件

运行编译文件 java Nihao

计算机执行class二进制文件，程序完成~

 安装IDEA环境与使用

第二天 java基本语法：

public class Nihao {  //class 申明一个类
    public static void main(String[] args) {  //main方法
        System.out.println("Hellow World!");   //打印输出字符串
        System.out.println("鸡哥你太美!");
    }
}

　　

1.申明一个类

public class Nihao {

}

 

2.main主方法，程序入口

public static void main(String[] args){

代码区域 };

 

3.代码区域：打印一句话 

System.out.println("Hellow World!"

 

变量与常量：

变量可以变的量声明一个变量格式

[数据类型] [变量名称];

public class Nihao {  //class 申明一个类
    public static void main(String[] args) {  //main方法
        int x;  //声明一个整数类型的变量
        x = 10; //赋值x=10
        System.out.println(x); //打印x这个值
        int a,b; //申明a和b都是整数类型
        a = 11;
        b = 12;
        System.out.println(a);
        System.out.println(b);
    }
}

 

第一个关键字 final

唯一的意思只能使用一次，唯一的意思

 

第三天基本的数据类型

 知识点：

二进制

1111=2的3次方+2的2次方+2的1次方+2的0次方=8+4+2+1=15bit

在java中无论小数和整数都要带有符号，首位是符号位1代表负数0代表正数

如：4bit位 1111= 负号+2的2次方+2的1次方+2的0次方=-（4+2+1）=-7，0111= 正号+2的2次方+2的1次方+2的0次方=4+2+1=7，所以4bit位范围就是 ±7 称为原码

为了方便计算演化出来反码（正数反码都一样，负数除符号位全取反）

-3=1 11 反码=1 00

但是有±0，为了消除-0，JAVA中存储和使用负整数时，采用的就是补码形式，使用了补码（反码在+1）

-3补码=反码 1 00+1=1 01

所以所以4bit位范围就是 -8~7

 

第四天

整数型：

 

名称	空间(bit)	范围
byte	8	-128~+127
short	16	-32768~+32767
int	32	-21亿~+21亿
long	64	-92万兆~+92万兆

 

 

浮点型：

 

名称	空间(bit)	范围
float	32
double	64	最大

 

字符类型

名称	空间(bit)	范围
char	16	0~65535
String

 

 

布尔类型 boolean 

名称
true	真	1
false	假	0

 

第五天 运算符

 

赋值运算符 =

int a = b = 555 从右往左赋值  a=555

 

算数运算符 + - * /

String a="Hello"

String b="World"

String c=a+b

取模运算：保留余数 %  ，列如 偶数取模一定是0，奇数取模一定是1

 转义字符 \n 换行

 

括号运算符（ ）

1.运算优先级

2.强制类型转换

int a=10;

short b=(short) a;

 

自增自减运算符

int a = 10; 

a =  a + 1 = a ++ (先出结果在自增)   ++a 先自增在出结果

a =  a - 1  = a- -  (先出结果在自增)   - -a 先自减在出结果

自增 x （x代表自增自减几）

int a =2;

 a += x；

自减 x

int a =2;

 a -= x；

 

位运算符  & | ^ ~

按位与 &

9 & 3 = 1

9=1001

3=0011

二进制比较 都是1 结果就是1 否则就是0  所以二进制结果=0001

 

按位或 |

9 | 3 = 1011=11

9=1001

3=0011

任意一个为1（不能同时为0）那结果就是1

 

 按位异 ^

9 ^ 3 = 1010 = 10

9=1001

3=0011

两边不同的情况下结果才是1，也就是说一边1一边0的这种情况

 

按位取反 ~

二进制取反0变1，1变0

byte c = ~ 127 

= 01111111取反 =10000000=-128

 

位移运算符

byte c = 1<< 2; 左位移运算

 1=00000001 往左移动2位=00000100=4   正数尾部0填充

左移操作结果会*2，所以说除了* 进行成2之外还可以用左移操作完成

>>右移同理

-1>> 2

-1=11111111 11111111往左移动2位=11111111 11111111  （负数填充1）

对于负数来说，左移右移不会改变符号位上数字（负数填充1）

>>> 意思加上符号位位移 用0补位

<<<不存在无符号左移

 

关系运算符 boolean类型主场

 关系类型判断只可能是真或者假，所以说得到的结果只能是boolean类型

关系运算符包括：

符号	名称
>	大于号
>	小于号
==	等于号（单个等号是赋值）
!=	不等于
>=	大于等于
<=	小于等于

 

判断两个条件 a 小于等于100 大于等于60

&&	与运算	要求两边同时为true 才能返回true
||	或运算	要求两边至少有一个为true才能返回true
!	非运算	一般放在表达式最前面，表达式用括号括起来，表示表达式的结果进行反转

 

int a = 10;

boolean b = !(a>5)   //取反，a=1-大于5是 true 前面加上了!输出结果就是false

 

三元运算符：表达式? 结果1 ：结果2  

条件？真执行：假执行

当a > 10 ，给b赋值A

当a <=10，给b赋值B

 

流程控制

代码块与作用域{ }花括号里面的变量 作用域就在{ }里面

 

if(条件判断) 判断成功执行的代码;

 int a =10;

if(a>5){ System.out.println("Hello World!");}

 if(条件判断) else 其他选择

  if(条件判断) else if   循环判断

 

 switch选择语句

 default其他情况

 

for循环　　for(表达式1;表达 式2;表达式3)循环体;

 示例：

快捷方式

contnue 跳过某一轮循环

 if (i == 1) contnue;

break 提前结束循环

 

while（循环条件）循环体;

 

 先执行在判断 do while语句

 

if是布尔类型选择执行（范围匹配某个值）

switch是多选题看符合那些执行（精确匹配某个值） 

for循环 明确重复循环多少次，一直到满第二个条件

while循环 不明确循环多次

 

第六天实战题

 水仙花束

public class shuixianhua {
    public static void main(String[] args){
        for (int i = 100; i < 1000; i++) {
            int a =i % 10;
            int b =i /10 % 10;
            int c =i /100 % 10;
            if (a*a*a + b*b*b + c*c*c == i)
            System.out.println(i+"是水仙花束");
        }
    }
}

 

 9X9

    public static void main(String[] args){
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= 9; j++)
                System.out.print(j+ "X" +i+ "=" +i*j+ "  ");
                System.out.println( );
        }
    }

 

第七天 面向对象

　　类与对象

类的概念：对一类事物的描述，抽象的，概念上的定义

对象是某一类事物实际存在的每个个体，因而也被称为实例

如：

 A：谁拿了我的手机

B:是个人 （指类）

A:废话我肯定知道是个人

B:是某某某（指对象）

 

类里面含有属性

public class Person {       //这是一个类
    String name;            //属性
    int age;                //属性
    String sex;             //属性
}

 

 

有类就可以创建对象了，new 类名();

 

public class Main {
    public static void main(String[] args) {    //主方法
        Person person = new Person();           //引用类创建对象
        person.name = "小严";                    //使用类属性
        person.age = 18;                        //使用类属性
        person.sex = "男";                       //使用类属性
        System.out.println(person.name);
    }
}

 

方法的创建和使用

方法就是类的行为，比如一个人会跳会走路，会唱歌

方法定义：

　　返回值类型 方法名称（ ）{

　　　　　　方法体……

　　　　　　}

Void 表示方法没有返回值

 

public class Person {       //这是一个类
    String name;            //属性
    int age;                //属性
    String sex;             //属性

    void hello(){     //创建个没有返回值（void）的方案，名字叫做 hello

        System.out.println("我叫 " + name + ",今年" + age + "岁!");
        //方法体内容是打印
    }
}

使用方法

public class Main {
    public static void main(String[] args) {    //主方法
        Person person = new Person();           //引用类创建对象
        person.name = "小严";                    //使用类属性
        person.age = 18;                        //使用类属性
        person.sex = "男";                       //使用类属性
        person.hello();                          //使用自定义的hello方法

    }
}

我叫 小严,今年18岁!

进程已结束,退出代码0

 创建有返回值的计算方法

    int sum(int a,int b){
        //创建一个有返回值 int 类型方法，在括号内定义类型和参数名称  形式参数

        int c = a + b;
        //方法体：计算a+b

        return c;
        //返回输出值C 告诉别人返回结果
    }

使用此方法

        //int a = 18;
        //int b = 20;
        //int jisaun = person.sum(a,b);
        int jisaun = person.sum(18,21);
        System.out.println(jisaun);

 

形参/实参

方法中的参数/实际参数

 

方法的传递

外部的使用的方法，实参在类只做复制

引用自己的类改变的就是同一个类

 

 

第八天 方法进阶

 this关键字，指类中属性名重复指定为类中属性名

方法的重载

　　指2个相同的方法名，不同类型

    int sum(int a,int b){
        //创建一个有返回值 int 类型方法，在括号内定义类型和参数名称  形式参数
        int c = a + b;
        //方法体：计算a+b
        return c;
        //终止方法 返回输出值C 告诉别人返回结果
    }

    double sum(double a,double b){
        //方法的重载，方法名一样，作用智能，sum这个方法能同时支持 int和double类型计算
        double c = a + b;
        //方法体：计算a+b
        return c;
        //终止方法 返回输出值C 告诉别人返回结果
    }

 

方法之间可以互相调用

    void test(){
        say();   //直接方法名，调用类中方法
    }
    void say(){
        test();
    }

 

构造方法 （构造函数）

　　成员变量初始化操作存储地

 

    Person(){  //java编译出来的class文件中自带一个构造方法，类名字(){}
        
    }

我们可以去声明，手动去修改

    //第一个构造方法
    Person(String name,int age,String sex){  //java编译出来的class文件中自带一个构造方法
        //new 使用则会个类，必须需要形参
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    Person (){//创建2个构造方法

    }

 

类中有代码块执行顺序，初始值-代码块-构造方法

 

 

 

 类成员属性：

 　　成员变量，成员方法，构造方法

 

第九天静态变量静态方法

（静态的属于类，动态的属于对象）使用类名.方式直接使用，不用创建对象，不用new 直接使用

关键字：static 定义静态变量

 

 执行顺序

 

第10天来着

包的声明和导入

 　　包其实就是用来区分类位置的东西（类似与namespace）通过包的形式将这些类进行分类存放

package com.tset;
//package 关键字代表类位置
import com.tset.entity.Person;
//引用其他路径下的类

 import com.tset.entity.*; 表示导入包中所有类

 

访问权限控制（可见性）

 java中引用了访问权限控制，我们可以为成员变量、成员方法、静态变量、静态方法甚至是类指定访问权限

默认：类本身和同包类访问

private-私有 只能被当前类访问

protected-受保护，只能被当前类和同胞中其他类访问，也可以被子类访问

public 公开的类，可以在任何地方使用

 

静态方法可以通过 import直接导入

import static com.tset.entity.Person.agetest;

 

第11天 类三大特性

　　继承 封装 多态

 

封装：为了保证变量安全性，通过外部接口访问类成员，封装就是通过访问权限控制来实现的

打个比方：属性和方法都是private 私有的，外部包是无法访问的，但是可以通过创建一个public  方法，或者构造函数，来实现访问的方法或者内容

  private void abc(){
        System.out.println("这是一个限制当前类访问的方法");
    }
    public void def(){ //可以通过公开的方法来使用封装的方法
        abc();
    }

 

 继承：

 通过关键字

 

public class Worker extends Person{  //创建Person子类，使用extends关键字 指定父类Person
}

 关键字 super 父类

当继承父类有构造函数 形参的时候，子类一样需要给默认值 （无参可以省略）

public class Person1 {  //父类
    String name;
    int age;
    String sex;

    public Person1(String name,int age,String sex){ //父类在构造函数的时候需要形参初始化
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
}

子类继承方式，需要super （形参）

public class Student extends Person1{
    public Student(String name,int age,String sex){ //与父类构造函数相同
        super(name,age,sex); //值
    }
}

关键字

instanceof  

判断对应类型，是不是子类继承类

 Person1 person1 = new Student("小明",18,"男");
        if(person1 instanceof Student){ //instanceof 判断对应类型，是不是子类继承类
            System.out.println("是Student类型的");
        }

返回值真

另外子类的属性跟父类属性可以同名但是使用的时候子类方法使用的是优先子类中的属性

比如：

public class Worker extends Person1{
    String name;
    public Worker(String name, int age, String sex) {
        super(name, age, sex);
    }  //创建Person子类，使用extends关键字 指定父类Person

    public  void  work(){
        System.out.println("我是 "+name+",我在工作！");
        //这里的name是之当前类中的name非父类name
    }

}

  Worker worker = new Worker("小严",29,"男");
        worker.work();//输出的结果是 我是 null,我在工作！

如果说上面方法中需要使用的是父类的属性name需要加关键字 super.name

public class Worker extends Person1{
    String name;
    public Worker(String name, int age, String sex) {
        super(name, age, sex);
    }  //创建Person子类，使用extends关键字 指定父类Person

    public  void  work(){
        System.out.println("我是 "+super.name+",我在工作！");
        //这里的name是之当前类中的name非父类name
    }

}
        Worker worker = new Worker("小严",29,"男");
        worker.work();
        //我是 小严,我在工作！

继续完事了记得总结

Object类 所有类的祖宗

 equals 方法 用户判断当前对象跟传入对象是否是同一对象

注意这里指判断是否同一对象并非值

 第12天方法的重写

重写与重载不用，重载是方法的多种形式，重写是覆盖原方法

比如我们现在不希望使用Object类中提供的equale方法，那么我们就可以将其重写

 

 

    @Override  //@屎黄色的是注解
    public boolean equals(Object obj) {  //重写方法要求于父类定义完全一致
        //equals 方法是检测一个对象是否等于另一个对象 对象A.equals（对象B）等于返回true 不等于则返回 files
        if (obj == null)  return false;  //方法体的内容：如果obj 等于 null 结束判断返回false
        if (obj instanceof Person1){
            Person1 person1 = (Person1)  obj;  //强制转换类型进行比较
            return this.name.equals(person1.name) && //字符串比较不能用=号，需要用equals
                    //这里相等equals就会返回真
                    this.age == person1.age &&
                    this.sex.equals(person1.sex);
        }
        return false;
    }

注意如果我不希望别的子类重写某些方法 可以在方法前面加 final关键字 表示最终形态

public final void test(){
System.out.println("方法一");
}

final 关键字好几个用的地方，类、属性、方法

 

可以在子类方法里面使用原方法体，使用 super关键字

 

 第13天 类的多态

 多态：多个不同的对象对同一消息做出响应，同一消息根据不同的对象而采用各种不同方法

 

 抽象类：

什么是抽象类？抽象类就是在 class 前面加上个关键字  abstract

 

public abstract class Person2 { //这是说明这是一个抽象类
    String name;
    int age;
    String sex;

    public Person2(String name,int age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    protected abstract void exam();
    //protected-受保护，只能被当前类和同胞中其他类访问，也可以被子类访问
    //abstract 这是一个抽象方法，子类必须重写

}

有抽象方法的一定是抽象类，有抽象类不一定有抽象方法

 第十四天 接口

 新建一个接口

interface

 

 

public interface Study { //interface定义为接口
    //接口里只能有抽象方法
    void study();//public abstract（定义抽象类/方法） 可以省略默认的
}

使用抽象方法class 类名 + implements + 接口名

public class Student1 extends Person2 implements Study{
    //implements 实现接口的意思 Study 接口名
    public Student1(String name, int age, String sex) {
        super(name, age, sex);
    }
    public void study(){
        System.out.println("我学习比较佛西");
    }
}

 友情解释一下new Person 就是对类进行实例化

 接口可以继承多个

public class Student1 extends Person2 implements Study,Cloneable{
 }

Study 和 Cloneable 都是接口类

default 关键字  定义抽象方法默认实现

public interface Study { //interface定义为接口
    //接口里只能有抽象方法
    void study();//public abstract（定义抽象类/方法） 可以省略默认的

    default //定义抽象方法默认实现
    void test (){
        System.out.println("我是默认实现");
    }
}

 第十五天介绍一下Object类中提供克隆的方法

 什么现在才介绍？因为它需要实现接口才可以使用

1.需要继承 Cloneable  接口类

2.提升权限 clone 快捷输入后

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

需要将  protected 升级成 public

 

        Student1 student1 = new Student1("小静",29,"保密");
        //复制过程 1.使用复制函数 student1.clone
        //2. student1 clone = student1.clone
        //3.强制转换 给的是Object 转给 Student1
        Student1 clone = (Student1) student1.clone();
        //student1 复制成 clone

在 Java 中，对象的克隆是通过 clone() 方法来实现的。clone() 方法定义在 Object 类中，因此所有的类都可以调用该方法来创建自身的副本（克隆）。

然而，在使用 clone() 方法进行对象克隆时，需要进行类型转换。这是因为 clone() 方法返回的是一个 Object 类型的引用，而不是原始对象的类型。为了将其赋值给特定类型的变量，我们需要将其强制类型转换为目标类型。

在你提供的代码中，student1 是一个 Student1 类型的对象，而 clone() 方法返回的是一个 Object 类型的引用。为了将克隆得到的对象引用赋值给 Student1 类型的变量 clone，所以需要进行强制类型转换，即 (Student1) student1.clone()。

下面是一个示例说明：

java复制代码

class Student1 implements Cloneable {
    private String name;
    
    // 构造函数和其他方法省略
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) {
        Student1 student1 = new Student1();
        
        try {
            Student1 clone = (Student1) student1.clone();
            // 克隆成功，将克隆得到的对象引用赋值给 Student1 类型的变量 clone
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

 

需要注意的是，为了使一个类能够被克隆，该类必须实现 Cloneable 接口，并且覆盖 clone() 方法。在上述示例中，Student1 类实现了 Cloneable 接口，并重写了 clone() 方法。

 

强制类型转换（也称为显式类型转换）是将一个数据类型转换为另一个数据类型的操作。在Java中，当需要将一个较大范围的数据类型转换为较小范围的数据类型时，就需要进行强制类型转换。

强制类型转换的格式如下：

java复制代码

目标类型 变量名 = (目标类型) 表达式;

以下是关于强制类型转换的一些要点：

• 强制类型转换会丢失精度或导致数据截断。当将一个可以表示更大范围数据的类型转换为较小范围的类型时，可能会丢失一些信息。
• 强制类型转换只能在具有继承或实现关系的类之间进行。例如，可以将子类对象转换为父类对象，或者将实现接口的类转换为该接口类型。
• 强制类型转换应该谨慎使用。由于可能导致数据丢失或错误，因此在进行强制类型转换时，需要确保转换是安全和合理的。
• 在进行强制类型转换之前，最好进行类型检查，以避免在转换过程中发生异常。可以使用 instanceof 运算符来检查对象是否属于特定的类或接口。

以下是一个示例说明强制类型转换的情况：

java复制代码

double d = 3.14;
int i = (int) d; // 强制类型转换，将 double 类型转换为 int 类型
System.out.println(i); // 输出：3

在这个示例中，double 类型的变量 d 被强制转换为 int 类型，并赋值给 i。由于强制类型转换会舍弃小数部分，所以 3.14 的小数部分被丢弃，结果为 3。

需要注意的是，如果进行不合理的强制类型转换，例如将一个无关类之间进行转换或者超出目标数据类型范围的转换，可能会导致编译错误或运行时异常。

总之，强制类型转换是一种将一个数据类型转换为另一个数据类型的操作，但需要注意潜在的精度损失和数据截断问题。确保在进行强制类型转换时谨慎操作，并尽可能进行类型检查以避免异常情况的发生。

 

对象克隆的主要作用是：

1. 数据保护：通过克隆，可以创建一个对象的副本，并对副本进行修改或处理，而不会影响到原始对象。这样可以保护原始对象的数据完整性和安全性。

2. 提供备份机制：克隆允许在需要时创建对象的备份，以便在某些操作失败或发生错误时，能够恢复到之前的状态。

3. 性能优化：在某些情况下，直接克隆对象比重新创建一个新对象更高效。克隆避免了重新初始化对象所需的成本和时间，因为已经有一个具有所需属性的现有对象。

需要注意的是，对象的克隆是浅拷贝（Shallow Copy），即只复制对象本身和其内部引用类型的地址，而不会递归复制引用的对象。如果需要进行深拷贝（Deep Copy），也就是复制所有嵌套对象的副本，需要自行实现。

 

 十六天 接口继承

接口继承不仅要实现子类方法还得实现父类方法

接口继承可以继承多个接口 用  implements 接口A , 接口B

接口虫鸣方法只是覆盖

 

枚举类

快速生成方法

在Java中，Getter和Setter是一种常见的命名约定，用于访问和修改类的私有属性（成员变量）。Getter用于获取属性的值，而Setter用于设置属性的值。这个约定有助于封装和控制属性的访问。

以下是关于Getter和Setter的一些要点：

• Getter方法：Getter方法用于返回私有属性的值。它通常以get为前缀，后跟首字母大写的属性名称，没有参数，并指定返回类型为属性的数据类型。例如，如果有一个名为name的私有属性，那么对应的Getter方法应该命名为getName()。

• Setter方法：Setter方法用于设置私有属性的值。它通常以set为前缀，后跟首字母大写的属性名称，并且接受一个参数，参数类型与属性的数据类型相同或兼容。通常情况下，Setter方法不返回任何值，因此声明为void类型。例如，如果有一个名为name的私有属性，对应的Setter方法应该命名为setName(String name)。

• Getter和Setter方法的命名约定遵循JavaBean规范。这样做的好处是可以通过标准化的命名方式来自动生成代码，提高了代码的可读性和维护性。

• Getter和Setter方法使得类的属性能够被外部访问和修改，并且可以在内部进行数据验证、控制和逻辑处理。

以下是一个示例，展示了如何使用Getter和Setter方法：

class Person {
    private String name;

    public String getName() {
        return name;
    }

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

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        System.out.println(person.getName()); // 输出：Alice
    }
}

 十七天 枚举类

 

 

enum  枚举名
1。创建枚举

public enum Status {
    RUNNING,
    STUDY,
    SLEEP;
}

 

2.方法名改为枚举名字

public class Test {
    public Status status;

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }
}

3.使用枚举

public class Main1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Test test = new Test();
        test.setStatus(Status.SLEEP);
 System.out.println(test.getStatus()); } }

 进阶使用，覆盖构造方法，获取中文名称

package com.tset.entity;

public enum Status1 {
    RUNNING("睡觉"), STUDY("学习"), SLEEP("跑步");
    //因为覆盖了构造方法 枚举需要添加实参 名字后面+（实参）
    private final String name;   //添加枚举的成员变量
    Status1(String name){   //覆盖原有的构造方法
        this.name = name;
    }

    public String getName(){  //获取封装的成员变量
        return name;
    }
}
//顺序是当作一个类 添加了个属性，覆盖了构造方法，枚举名称需要添加实参，后面获取的时候可以获取枚举值.getName名称

public class Main1 {
    public static void main(String[] args) throws CloneNotSupportedException {

        Test2 test2 = new Test2();
        test2.setStatus(Status1.RUNNING);
        System.out.println(test2.getStatus().getName());
　　　　//获取中文名称
    }
}

 

面向对象高级篇

基本类型包装类

　　包装类介绍

　　

 

 包装类实际上就是将我们的基本数据类型，封装成一个类（运用了封装思想）

 

public class Main3 {
    public static void main(String[] args) {
        //高级 包装类
        Integer i = new Integer(10);
        System.out.println(i);
    }
}

 

字符串转 int 类型 转换方法

 

 十八天 特殊包装类

 1.用于计算超大数字的Biglnteger

 2.用于精确计算场景 BigDecimal

 

public class Main3 {
    public static void main(String[] args) {
        //高级 包装类
        Integer i = new Integer(10);  //包装类
        System.out.println(i);

        BigInteger a = BigInteger.valueOf(100); //特殊类，超大整数计算
        System.out.println(a);

        BigDecimal b=BigDecimal.valueOf(10);  //特殊类 超小小数
        b = b.divide(BigDecimal.valueOf(3),100, RoundingMode.CEILING);
        //计算10/3的结果，精确到小数点后100位
        //RoundingMode是舍入模式，就是精确到后一位时，该怎么处理，这里CEILING表示向上取整
        System.out.println(b);
    }
}

 十九天数组

 数组目的是我需要100个int变量不需要int 100次

只需要 int []  a = new int[100]{1,2,3,4,5,6……100};   代表了100个int 的属性

 

public class Main3 {
    public static void main(String[] args) {

        //定义一个一维数组变量 = 数组是10个int变量
        int[] array = new int[10];
        //语法：类型[] 名称 = 新建 类型[数据空间个数]
        System.out.println("数组的第一个元素为："+array[0]); //使用变量名[下标]的方式访问


        int[] array1 = new int[]{1,2,3,4,6};
        //默认给array1   5 个int变量空间 分别是值 12346
        System.out.println(array1.length); //length 方法访问数组长度
        System.out.println("数组的第一个元素为："+array1[0]); //使用变量名[下标]的方式访问
        //注意 数组的下标是从0开始不是从1

　　　　　　array1[0] = 2;//给数组赋值 数组的第一个空间 = int 2
　　　　　　System.out.println(array1[0]);

    }
}