Java程序

java是一种混合型语言，先编译成文本，再转换为机器指令

Java虚拟机封装了底层操作系统的细节，向上提供Java运行环境

​ JDK=JRE+相关的开发环境

​ JRE=JVM+基础类库

从Java9开始，将jar打碎成为jmod，精简化，占用更少的空间

编写代码：事件->功能->类（相互协作）

使用命令行运行一个Java程序

1、新建一个文档写入Java代码

2、重命名为name.java，注意：name应与Java代码中的class保持一致

3、打开命令行

​ 1》在命令行找到文件位置后，

​ 2》输入：javac name.java ，

​ 3》会在同一文件夹下自动生成一个name.class文件，

​ 4》再输入java name

基本数据类型

数值型

整数类型（以带符号二进制补码的方式保存）

byte

short

int

如何处理大的整数：Java中有BigInteger类，支持大整数加减法

long

long num=12345678945L;

float

double

double y1 = 32.12d;

使用double进行数值运算，其结果是近似的（十进制与二进制转换过程中会有精度损失），故浮点数的比较一般使用：|d1-d2|<10^-6，即可认为两者相等

eg：

public class Test1 {
    public static void main(String[] args) {
        System.out.println("0.01+0.05="+(0.01+0.05));
    }
}//输出结果：0.01+0.05=0.060000000000000005

解决办法：使用BigDecimal类！

import java.math.BigDecimal;//intellij中包会自动导入
public class Test1 {
    public static void main(String[] args) {
        char[] val;
        BigDecimal a=new BigDecimal("0.05");//注意，此处参数为字符串
        BigDecimal b=new BigDecimal("0.01");
        System.out.println("0.01+0.05="+a.add(b));//加
        System.out.println("0.01+0.05="+a.subtract(b));//减
        System.out.println("0.01+0.05="+a.multiply(b));//乘
        System.out.println("0.01+0.05="+a.divide(b));//除
    }
}
/*0.01+0.05=0.06
0.01+0.05=0.04
0.01+0.05=0.0005
0.01+0.05=5*/

字符型

布尔型：

​ 有true和false两个值，Java中不能和0，1互换

boolean b1 = true;

常量和变量

声明常量：

eg：

final double PI = 3.14159;

在程序中一般将常量分类，写入一个interface（接口）中，方便调用

变量作用域：（一个大括号）

类成员变量

声明在类中，作用域为整个类（class）

方法参数变量

在方法的参数部分声明的变量，作用域为整个方法；

局部变量

局部变量声明在当前代码块，作用域局限在当前{}内

异常处理参数变量

异常处理代码块中，（与方法参数变量类似）

运算符

位运算符

按位与

按位或

按位异或

按位取反

右移位

左移位

无符号右移位

数据类型转换

低级向高级转换，系统自动执行

高级向低级转换，需要强制类型转换：

eg:

int a = 3;

double b = 4.0;

a = (int)b;

输入输出：

输入输入都是以流（stream）输入输出

使用 Scanner 类：

import java.util.Scanner;//导入包
public class helloword {
    private static int value=2;
    public static void main(String[] args){
        //这是一个Java程序：
        Scanner in = new Scanner(System.in);//创建一个对象
        int a=in.nextInt();//字符串转整形
        int b=in.nextInt();
        int value=a+b;
        System.out.println(value);
    }
}

创建对话框

import javax.swing.JOptionPane;//导入包
public class Welcome {
    public static void main(String[] args){
        String firstNumber =
                JOptionPane.showInputDialog("Enter your age :" );//输入

        JOptionPane.showMessageDialog(
                null, "Welcome\nto\nJava\nProgramming!" );//输出
    }
}

在Java中定义方法（即C中调用函数）

语法格式：

访问权限 [static] 返回值类型 方法名( 参数列表 )

{

语句

…

}

import java.util.Scanner;
public class helloword {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int a=in.nextInt();
        int value=square(a);
        System.out.println(value);
    }
    public static int square(int t){//求平方的方法
        return t*t;
    }
}

Java中支持可变参数的方法：

调用可变参数方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

public class Test4 {
    public static void main(String[] args) {
        System.out.println(max(1,5,9,8,7));
    }
    public static int max(int... values){//...位于参数类型和参数变量名之间
        int large = Integer.MIN_VALUE;
        for(int v:values){//java中访问数组的方式
            if(large<v)
                large=v;
        }
        return large;
    }
}

类与对象：

创建类（定义类）

在原来的class外再开一个class（注意不能用public了，一个java文件中只能有一个public class）

定义类就是要定义类的属性与行为；

格式如下：

[访问说明符] [修饰符] class 类名

{

​ 类成员变量声明；

​ 类方法声明；//方法就是类的行为

}

创建对象

1、定义对象：

类是对象的实例，定义对象就和定义变量一样

2、给对象分配内存：

使用new关键字

import java.util.Scanner;
class Friend{
    int number;
    public void setnum(int n){
        number=n;
    }
    public int getnum(){
        return number;

    }
}
public class Student {
    public static void main(String args[]){
        Friend friend1;
        friend1 = new Friend();
        Scanner in = new Scanner(System.in);
        int xuehao = in.nextInt();
        friend1.setnum(xuehao);
        System.out.println(friend1.getnum());
    }

}

类的"构造方法"

类中的一个特殊的方法；一般对类成员变量进行*初始化*工作（使用new关键字创建对象时，构造方法被自动调用）

​ 1、方法与类有相同的名称

​ 2、不含返回值

每个类中默认有一个构造方法，如果没有声明，系统会自动为这个类产生一个构造方法

注意：如果将一个类的构造方法设置为private 类，那么这个类方法不能创建新的对象

访问说明符和修饰符

访问说明符：

public（公共类）

​ 表明它可以被其他类所访问和引用

eg：类的属性一般不要用public，否则会造成安全性和封装性下降，类的方法一般用private

protected

​ 子类可以继承父类的数据成员和方法

private（私有类）

​ 只能被该类自身访问和修改

friend（缺省）

​ 没有规定访问说明符的情况；

​ 只能被同一个包（package）的类访问和引用（包访同性）

修饰符

this引用

一个对象中的成员方法，可以引用另一个对象的成员，也可以引用自己的成员，这时候就用到了this

在成员方法中，访问的同类成员前加不加this都一样，但是在某些特殊情况下费用this不可

重载

方法重载

在一个类中允许同名方法的存在，用不同的形式参数列表（个数、类型、顺序）来区分

构造方法重载

也是根据参数来区分

static、final修饰符的应用

static关键字

静态属性：

在属性前加上static，会使得不同的对象使用同一个属性，改变一处，则所有都改变

如果在一个类中使用static变量，那么新建的每一个类对象中的此变量引用同一个变量值，一处改变，所有都改变（被所有类对象共享）

静态代码块：

只能定义在类里面，独立于任何方法；

里面变量都是局部变量；

静态代码块会自动执行（先于main函数）；

静态代码块只能访问静态成员；

静态方法：

在外部调用静态方法时，既可以使用“类名.方法名”，也可以使用“对象名.方法名”；

静态方法在访问本类成员时，只允许访问静态成员，不能访问实例字段；

final关键字

类似于C中const的功能

字符串类

字符串的读取方式是“只读”，当我们在原来的字符串上添加一段时，会创建一个新的字符串

String类

构造方法：

根据所给参数不同，有多种构造方法

求字符长度：

String.length()

字符串连接，与其他数据类型连接：

使用 “+”

字符串中截取一个字符：

charAt( )

截取多个字符并存入另一个字符串中：

字符串的比较：

equals()

区分大小写，返回值为true或false

equalsIgnoreCase()

忽略大小写，返回值为true或false

equals()和“==”的区别

equals()比较字符串对象中的字符是否相等；

“==”比较两个对象引用是否指向同一个对象；

Stringbuffer类

。。。

数组

与C语言不同的地方：先声明数组，再给数组分配空间

int a[];

a = new int[20];//分配一个大小为20的int型数组
int a[] = new int[20];//简洁写法

其他的初始化数组，给数组赋值与C一样

包装类

八种基本的数据类型分别对应八种包装类

用途：

1、作为和基本数据类型对应的类型存在，便于涉及到对象的操作

2、包含每种基本数据类型的相关属性，以及相关的操作方法

Integer类型

int m = 3;
Integer M = m;//自动装箱
int n = M;//自动拆箱

String s1 = "123";
int n = Integer.parseInt(s1);//字符串转数字
String s2 = Integer.toString(n);//数字转字符串

注意：使用Integer创建一个-128~127内的对象，会在内存中直接返回一个已经建好数组空间，在范围之外的数据会新建内存空间

//示例中“==”比较的是是否指向同一个地址
Integer a = 10;
Integer b = 10;
System.out.println(a==b);
//true
Integer a = 1000;
Integer b = 1000;
System.out.println(a==b);
//false

数字处理类

数字格式化

使用DecimalFormat类创建对象对浮点数进行格式化输出

import java.text.DecimalFormat;
public class Test4 {
    public static void main(String[] args) {
        double a = 45123.154815;
        DecimalFormat f = new DecimalFormat();
        f.applyPattern("#.##");//规定格式
        System.out.println(f.format(a));//格式化输出
    }//输出：45123.15

}

数学运算

各种数学函数

随机数处理类Random

import java.util.Random;
public class Test1 {
    public static void main(String[] args) {
        Random random1 = new Random(50);//括号中50是种子
        int a = random1.nextInt(10);//括号中10是边界
        Random random2 = new Random(50);
        int b = random2.nextInt(10);//相同的种子生成相同的随机数
        System.out.println(a);
        System.out.println(b);
        Random r = new Random(System.currentTimeMillis());//以时间为种子，更为随机
        System.out.println(r.nextInt(10));
    }
}

日期类

使用Date类输出当前时间

public static void main(String[] args) {
    Date d = new Date();//新建Date对象，自动保存当前时间
    System.out.println(d);//输出：Wed Oct 14 20:07:43 CST 2020
}

继承

继承的方式包括单一继承（从一个基类派生）和多重继承（从多个基类派生）

基类与派生类的关系

基类抽象了派生类的公共特征

派生类是对基类的扩展

步骤

1、先创建父类

2、通过关键词extends创建子类

class 派生类名 extends 基类名{

//派生类

}；

注意：

1、子类可以自动继承父类中声明为public和protected类的变量和方法，但是不能继承private类的变量方法

2、必须在派生类中重写构造方法，构造方法不能继承

3、生成一个子类的同时会调用该子类所有父类的构造方法

Java中的包"package"

1、解决类的同名问题

2、便于代码复用与维护

3、使用import语句先导入，后使用

当使用Java运行一个class文件时，该文件必须放在指定包中，否则会产生错误

Java组件化开发

1、同一个class中对于复用代码可以“抽取方法”（即编写一个函数重复调用）

2、同一个project文件下的同一个Mudule中如果不同文件需要复用代码：在一个包中写完一个类，可以在另一个包中导入这个类，之间使用这个类中包含的方法

package bit.cs;//在这个包中定义一个类
public class MyStringUtil {
    public static String reverseString(String inputstring){
        StringBuffer buff = new StringBuffer();
        for (int i = inputstring.length()-1;i>=0;i--){
            buff.append(inputstring.charAt(i));
        }
        return buff.toString();
    }
}

package com.pack;
import bit.cs.MyStringUtil;//导入已经写好的包中的类，和导入Java自定义包一样
public class Reverse {
    public static void main(String[] args) {
        String astr = new String();
        astr = "abcd";
        System.out.println(MyStringUtil.reverseString(astr));//即可引用其功能
    }
}

3、同一个project文件下的不同的Mudule中如果不同文件需要复用代码：（mudule是一个Java文件编码的最小单位）

在一个mudule中写完一个类的方法后，要在另一个mudule中调用这个类方法，只需在File->Project Structure->dependencies栏目下加入需要调用类的依赖，然后正常导入即可使用类方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r3aIP8x7-1612238606131)(C:\Users\迷黎\AppData\Roaming\Typora\typora-user-images\image-20201018154308763.png)]

package bit.css;
public class MyStringUtil2 {
    public static String reverseString(String inputstring){
        StringBuffer buff = new StringBuffer();
        for (int i = inputstring.length()-1;i>=0;i--){
            buff.append(inputstring.charAt(i));
        }
        return buff.toString();
    }
}

//这两个package在不同的mudule中
package com.pack;
import bit.css.MyStringUtil2;
public class Reverse {
    public static void main(String[] args) {
        String astr = new String();
        astr = "abcd";
        System.out.println(MyStringUtil2.reverseString(astr));
    }
}

4、在不同的项目中调用同一段代码，可以将需要跨项目重用的代码，封装为一个单独的jar包，然后在新项目中将其添加到Build Path中，这样一来，只要有一个jar包，就可以直接使用jar包中的代码。（添加依赖关系）

在一个project中生成jar包，然后复制到另一个project中，添加需要调用jar包的依赖，即可使用该包中的类和方法

静态类

内部类

多态性

静态多态性（方法重载）：方法名相同，根据参数区分方法

动态多态性（方法重写）：在子类中重写父类的函数，调用时优先调用子类的

class Parent{
    public void function(){
        System.out.println("I am in parent");
    }
}
class Child extends Parent{
    public void function(){
        System.out.println("I am in child");
    }
}
public class Test {
    public static void main(String[] args) {
        Parent p1=new Parent();
        Parent p2=new Child();
        p1.function();
        p2.function();
    }
}                      //父类的引用指针指向子类的对象，子类方法重写父类的方法
//I am in parent
//I am in child

集合(collection)

set接口：存储一类唯一但无序的对象（继承于collection）

list接口：存储一类不唯一但有序的对象（继承于collection）

Map接口：提供一组键值对象，提供从key到value的映射

list概述

List通过索引来访问元素，可以看成是一种可“动态改变大小的数组”

public class TestArrayList {
    public static void main(String[] args) {
        List<String> books = new ArrayList<>();
        //向books集合中添加三个元素
        books.add("One book");
        books.add("Two book");
        books.add("Three book");
        System.out.println(books);
        //将新字符串对象插入在第二个位置
        books.add(1, "new book");
        for (int i = 0; i < books.size(); i++) {
            System.out.println(books.get(i));
        }
        //删除第三个元素
        books.remove(2);
        System.out.println(books);
        //判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf("new book"));
        //将第二个元素替换成新的字符串对象
        books.set(1, "new book2");
        System.out.println(books);
        //将books集合的第二个元素（包括）到第三个元素（不包括）截取子集合
        System.out.println(books.subList(1, 2));

    }
}
();
        //向books集合中添加三个元素
        books.add("One book");
        books.add("Two book");
        books.add("Three book");
        System.out.println(books);
        //将新字符串对象插入在第二个位置
        books.add(1, "new book");
        for (int i = 0; i < books.size(); i++) {
            System.out.println(books.get(i));
        }
        //删除第三个元素
        books.remove(2);
        System.out.println(books);
        //判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf("new book"));
        //将第二个元素替换成新的字符串对象
        books.set(1, "new book2");
        System.out.println(books);
        //将books集合的第二个元素（包括）到第三个元素（不包括）截取子集合
        System.out.println(books.subList(1, 2));

    }
}