java学习笔记(一)

序言

一周或两周前买了从零学JAVA PHP 从入门到精通几本书，正好空下来咕咕咕，学习下。也补一下期末（mac配置idea无敌！！！

基础知识

JAVA语言基础

拿到一门语言肯定是要先hello world了。

public class helloworld {
    public static void main(String[] args){
        System.out.println("hello world");
    }
}

当然这样就可以很容易的在控制台输出hello world了
这里需要注意的是一个java文件必须含有主函数，在eclipse或其他编译器中，还需要public class命名与文件名一致才可以正确运行JAVA，而IDEA可以自动识别（IDEA牛逼！

声明变量

在JAVA中，我们需要用

final double PI = 3.14159;//声明double型常量PI并赋值
final boolean BOOL = true; //声明boolean型常量BOOL并赋值

JAVA中整数/浮点类型

数据类型	字节	长度	取值范围
byte(字节)	1字节	8位	-128～127
short(短整形)	2字节	16位	-32768～32767
int(整形)	4字节	32位	-2147483648～2147483647
long(长整型)	8字节	64位	-9223372036854775808～9223372036854775807
float	4字节	32位	1.4E-45～3.4028235E38
double	8字节	64位	4.9E-324～1.7976931348623157E308

注：使用float需注明，例如：float f1=13.23f；long类型同上，char a = char 97

编写一个计算BMI指数的JAVA程序

首先我们以固定数据为例：

public class BMIexponent {
    public static void main(String[] args) {
        double height = 1.72;
        int weight = 70;
        double exponent = weight / (height * height);
        System.out.println("您的身高为"+height);
        System.out.println("您的体重为"+weight);
        System.out.println("您的BMI指数为"+exponent);
        System.out.println("您的体重属于");
        if (exponent < 18.5){
            System.out.println("体重过轻");
        }
        if (exponent >= 18.5 && exponent < 24.9){
            System.out.println("正常范围");
        }
        if (exponent >= 24.9 && exponent < 29.9){
            System.out.println("体重过重");
        }
        if (exponent > 29.9){
            System.out.println("肥胖");
        }
    }
}

根据书本例题进行手动编写：

将37摄氏度转换为整形的华氏度。华氏度=32+摄氏度*1.8

可以发现本题非常简单，所以我们直接编写即可

public class Fahrenheit {
    public static void main(String[] args) {
        int c = 37;
        double fahrenheit = 32 + (c * 1.5);
        System.out.println("摄氏度：" + c + "转化为华氏度为：" + fahrenheit);
    }
}

用boolean判断用户输入的值

可以发现本实例开始允许用户输入值，所以我们需要包含java中的库达到获取用户输入数据
import java.util.Scanner;

import java.util.Scanner;
public class loginservice {
    public static void main(String[] args) {
        Scanner passwd = new Scanner(System.in); //创建扫描器，获取控制台输入的值
        System.out.println("请输入密码");
        int password = passwd.nextInt(); //将用户输入的值给password
        boolean result = (password == 123456);
        System.out.println("您输入的密码是：" + result + "的");
        passwd.close(); //关闭扫描器
    }
}

模拟一个简单的计算器

import java.util.Scanner;
public class operator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个数字并用空格隔开：");
        double num1 = sc.nextDouble();
        double num2 = sc.nextDouble();
        System.out.println("和" + (num1 + num2));
        System.out.println("差" + (num1 - num2));
        System.out.println("商" + (num1 / num2));
        System.out.println("积" + (num1 * num2));
        System.out.println("余数" + (num1 % num2));
        sc.close();
    }
}

位运算符

运算符	含义
&	与
｜	或
～	取反
^	异或
<<	左移位
>>	右移位
>>>	无符号右移位

复合赋值运算符

+= ->>>>> a+=b - >>>>>> a= a+b 其他等同

三元运算符

boolean b = 20 < 45 ? true : false;

即，运算结果为真返回ture，为假返回false，等价于if else语句

boolean a;
if (20 < 45)
        a = true;
else
    a = false;

运算优先级

()
+ - //此为正负号
++ -- !
* / %
+ -
>> << >>>
> < = >= <=
== !=
&
^
|
&&
||
? :
= //赋值

流程控制

本章说的是判断，循环，跳转语句

判断

IF语句

流程很普遍了，这里就不写了

if(){
}

switch语句

也差不多吧，随便写个根据考试成绩判断等级的

import java.util.Scanner;
public class grade {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入成绩：");
        int grade=sc.nextInt();
        switch (grade){
            case 10:
            case 9:
                System.out.println("优");
                break;
            case 8:
                System.out.println("良");
                break;
            case 7:
            case 6:
                System.out.println("中");
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                System.out.println("差");
                break;
            default:
                System.out.println("无效");
        }
        sc.close();
    }
}

循环

while

while(){
}

do while

do{
}
while();

不同：while先判断在执行，do-while先执行后判断
例如比较密码则需要do-while

public class password{
    public static void main(String[] args){
        do{
            password = sc.nextLine();
        }while(!"45634351".equal(password));//equals() 方法用于将字符串与指定的对象比较。
    }
}

for

int sum = 0;
for (int i = 1;i <= 100;i++){
    sum+=i;
}

foreach

可用来方便的遍历数组，如

int arr[] = {1,2,3};
for(int x : arr){
    System.out.println(x);
}

输出 1 2 3

输出乘法口诀表

public class Multiplication {
    public static void main(String[] args) {
        int i,j;
        for(i = 1; i < 10; i ++){
            for(j = 1; j < 10; j ++){
                System.out.println(j + "*" + i + "=" + i * j + "\t");
            }
        }
    }
}

跳转

break

使用break语句跳出指定循环

Loop: for(){
    for(){
        break Loop;
    }
}

continue

跳到下一循环

public class test{
    public static void main(String[] args){
        for(int i = 1;i < 20;i ++){
            if(i % 2 == 0){
                continue;
            }
                System.out.println(i);// 输出偶数
        }
    }
}

数组

创建数组的方式

一维数组

//声明数组
int arr[];
double[] dou;
arr = new int[5];
//赋值方式
int a[] = {1,2,3};
int b[] = new int[] {4,5,6};
int c[] = new int[3];
int c[0] = 2;
//获取长度
int a[] = {1,2,3};
a.length

二维数组

//声明数组
int a[][];
char[][] a;
//分配内存
int a[][];
a = new int[2][4];
int b[][];
b = new int[2][];
b[0] = new int[2];
b[1] = new int[2];
//赋值方式与一维数组类似，就不写了

注：创建二维数组可以只声明‘行’而不声明‘列’的长度

杨辉三角形

public class YangHui {// 杨辉三角算法的实现
    public static void main(String[] args) {
        // 定义一个长度为10的二维数组
        int[][] Array_int = new int[10][];
        // 向数组中记录杨辉三角形的值
        for (int i = 0; i < Array_int.length; i++) {// 遍历行数
            Array_int[i] = new int[i + 1];// 定义二维数组的列数
            // 遍历二维数组的列数
            for (int j = 0; j < Array_int[i].length; j++) {
                if (i <= 1) {// 如果是数组的前两行
                    Array_int[i][j] = 1;// 将其设置为1
                    continue;
                } else {
                    // 如果是行首或行尾
                    if (j == 0 | j == Array_int[i].length - 1)
                        Array_int[i][j] = 1;// 将其设置为1
                    else// 根据杨辉算法进行计算
                        Array_int[i][j] = Array_int[i - 1][j - 1] + Array_int[i - 1][j];
                }
            }
        }
        for (int i = 0; i < Array_int.length; i++) {// 输出杨辉三角
            for (int j = 0; j < Array_int[i].length; j++)
                System.out.print(Array_int[i][j] + "\t");
            System.out.println();
        }
    }
}

交换数组位置

public class SwapRC {// 交换二维数组的行列数据
    public static void main(String[] args) {
        int i, j;// 定义两个变量，分别用来作为行和列的循环变量
        // 初始化一个静态的int型二维数组
        int[][] array = { { 8, 75, 23 }, { 21, 55, 34 }, { 15, 23, 20 } };
        System.out.println("—————原始数组—————");// 提示信息
        // 遍历原始的二维数组
        for (i = 0; i < 3; i++) {
            for (j = 0; j < 3; j++) {
                System.out.print(array[i][j] + "\t");// 输出原始数组中的元素
            }
            System.out.println();// 换行
        }
        int temp;// 临时变量
        // 通过循环调换元素的位置
        for (i = 0; i < 3; i++) {
            for (j = 0; j < i; j++) {
                temp = array[i][j];// 把数组元素赋给临时变量
                // 交换行列数据
                array[i][j] = array[j][i];
                array[j][i] = temp;
            }
        }
        System.out.println("——调换位置之后的数组——");// 提示信息
        // 遍历调换位置之后的二维数组
        for (i = 0; i < 3; i++) {
            for (j = 0; j < 3; j++) {
                System.out.print(array[i][j] + "\t");// 输出调换位置后的数组元素
            }
            System.out.println();// 换行
        }
    }
}

字符串

截取部分字符串

Srting e = new String(charArray2,4,2);//从下标为4的元素开始，截取两个字符

多行书写

System.out.println("i like"+
"java");

输出一个兔子

public class Graphics {//输出字符画
    public static void main(String[] args) {
        String pic = "      / \\`\\          __\n"
                   + "      |  \\ <code class="prettyprint" >\\      // \\\n"
                   + "      \\_/\\  \\-\"-/ /\\  \\\n"
                   + "           |       |  \\  |\n"
                   + "           (d     b)   \\_/\n"
                   + "           /       \\ \n"
                   + "       ,\".|.'.\\_/.'.|.\",\n"
                   + "      /   /\\' _|_ '/\\   \\\n"
                   + "      |  /  '-\"-'  \\  |\n"
                   + "      | |             | |\n"
                   + "      | \\    \\   /    / |\n"
                   + "       \\ \\    \\ /    / /\n"
                   + "        \"\\   :   /'\"`\n"
                   + "            \"\"\"\"`    ";
        System.out.println(pic);
    }
}//其实拿到题我还以为多难。。。

获取指定位置字符

public class CheckCarNum {// 创建一个CheckCarNum类
    public static void main(String[] args) {
        // 初始化一个String类型的数组carNum
        String carNum[] = {"津A·12345", "沪A·23456", "京A·34567"};
        for (int i = 0; i < carNum.length; i++) {
            // 控制台输出提示信息
            System.out.println("第" + (i + 1) + "张车牌号码：");
            System.out.println(carNum[i]);// 控制台输出提示信息
            char province = carNum[i].charAt(0);// 获取车牌第一字符
            if (province == '津')// 判断第一个字符是否是'津'
            {
                System.out.println("这张号牌的归属地：天津" + "\n");
            }
            if (province == '沪')// 判断第一个字符是否是'沪'
            {
                System.out.println("这张号牌的归属地：上海" + "\n");
            }
            if (province == '京')// 判断第一个字符是否是'京'
            {
                System.out.println("这张号牌的归属地：北京" + "\n");
            }
        }
    }
}

获取子字符串索引位置

例1:

import java.util.Scanner;
public class Website {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入网址：");
        String str = sc.next();
        if (str.indexOf("www.") != -1 && str.indexOf(".com") != -1 && str.length() > 7 && str.indexOf("..") == -1) {
            System.out.println("该网址为有效网址。");
        } else {
            System.out.println("该网址为非法网址。");
        }
        sc.close();
    }
}

例2:

public class PhoneNum {
    public static void main(String[] args) {
        String[] numbers = {"13677554103", "043182956123", "04326168799", "13004319255", "13394251304", "17763258893"};
        System.out.println("通讯录中的电话号码如下：");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("其中，通讯录中含有“0431”的电话号码有");
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i].indexOf("0431") != -1) {
                System.out.print(numbers[i] + " ");
            }
        }
    }
}

获取字符数组

str.toCharArray();该方法可将任意字符串转化为数组

import java.util.Arrays;
public class AscendingOrder {
    public static void main(String[] args) {
        // 声明并使用乱序的26个字母初始化String型的变量str
        String str = "qwertyuiopasdfghjklzxcvbnm";
        // 控制台输出升序前的String型的变量str
        System.out.println("升序前：\n" + str);
        // 将String型的变量str转换为char型的数组
        char[] c = str.toCharArray();
        // Arrays类调用sort()方法，对char型数组中的元素升序排列
        Arrays.sort(c);
        // 提示信息
        System.out.println("升序后：");
        // 遍历char型数组
        for (int i = 0; i < c.length; i++) {
            // 控制台输出char型数组中的元素
            System.out.print(c[i]);
        }
    }
}

字符串分割

public class StringSplit {
    public static void main(String args[]) {
        // 创建菜谱
        String a = "蒸羊羔,蒸熊掌,蒸鹿尾,烧花鸭,烧雏鸡,烧子鹅,卤煮咸鸭,酱鸡,腊肉,松花小肚";
        String denal[] = a.split(","); // 按照“,”将字符串分割成数组
        for (int i = 0; i < denal.length; i++) { // 遍历数组
            System.out.println("索引" + i + "的元素：" + denal[i]);// 输出元素的索引和具体值
        }
    }
}

例：模拟火车运行

import java.util.Scanner;
public class Ticket {
    public static void main(String[] args) {
        String train = "", destination = "", startTime = "";// 定义3个字符串，分别用来存储车次、车次信息及出发时间
        String[] columnName = { "车次", "出发站-到达站", "出发时间", "到达时间", "历时" };// 定义字符串输出
        // 定义二维数组，用来存储车次信息
        String[][] tableValue = { { "T40", "长春-北京", "00:12", "12:20", "12:08" },
                { "T298", "长春-北京", "00:06", "10:50", "10:44" },
                { "Z158", "长春-北京", "12:48", "21:06", "08:18" },
                { "K1084", "长春-北京", "12:39", "02:16", "13:37" } };
        // 遍历一维数组，用来输出标题
        for (int i = 0; i < columnName.length; i++) {
            System.out.print(columnName[i] + "\t");
        }
        String messages = "";// 定义字符串，存储获取到的各车次信息
        System.out.println();// 换行
        // 通过遍历二维数组显示各车次详细信息
        for (int i = 0; i < tableValue.length; i++) {
            for (int j = 0; j < tableValue[i].length; j++) {
                System.out.print(tableValue[i][j] + "\t");
            }
            train = tableValue[i][0];// 获取车次
            destination = tableValue[i][1];// 获取出发站及到达站
            startTime = tableValue[i][2];// 获取出发时间
            // 拼接车次信息
            messages += train + "次列车  " + destination + " " + startTime + "开" + ",";
            System.out.println();// 换行
        }
        System.out.println("请输入要购买的车次：");
        Scanner in = new Scanner(System.in);// 创建扫描器，用于进行输入
        String ticket = in.next();// 获取输入的车次
        String[] message = messages.split(",");// 对车次信息字符串进行分割，存储到一维数组
        for (int i = 0; i < message.length; i++) {
            if (message[i].contains(ticket)) {// 判断是否有用户输入的车次
                System.out.println("请输入乘车人(用逗号分隔)：");// 提示用户输入乘车人
                String names = in.next();// 存储输入的乘车人
                // 模拟现实购票信息
                System.out.println("您已购" + message[i] + ",请" + names + "尽快换取纸质车票。【铁路客服】");
            }
        }
        in.close();
    }
}

字符串大小写转换

使用to.UpperCase();与toLowerCase();

去除空白字符

str.trim();

例：模拟用户注册

import java.util.Scanner;
public class Register {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("欢迎注册：\n请输入用户名：");
        String userName = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();
        System.out.println("当前用户的用户名：" + userName.trim() + "\n当前用户的密码：" + password);
        sc.close();
    }

比较字符串是否相等

a.equals(str);用str中的内容与a比较

模拟用户登录

import java.util.Scanner;
public class Login {// 登录类
    public static void main(String[] args) {
        // 声明变量保存指定元素的下标
        int k = 0;
        // 静态初始化一个二维数组用来存储“用户名”和“密码”
        String[][] user = { { "mrsoft", "mingRI" },
                { "mr", "Mr1234" },
                { "miss", "MissYeah" },
                { "admin", "admin." } };
        // 提示信息
        System.out.println("------登陆------");
        // 提示信息
        System.out.print("用户名：");
        // 创建扫描器对象，实现控制台输入
        Scanner sc = new Scanner(System.in);
        // 接收控制台输入的用户名
        String userName = sc.next();
        // 通过循环判断控制台输入的用户名是否存在于二维数组user中
        for (int i = 0; i < user.length;) {
            // 控制台输入的用户名存在于二维数组user中
            if (user[i][0].equals(userName)) {
                k = i;// 获得数组元素下标
                break;// 结束循环
            }
            // i = i + 1
            i++;
            // 当i = 4时，控制台输出提示信息
            if (i == 4) {
                System.out.println("没有匹配到该用户的信息！");
                return;// 终止程序
            }
        }
        // 提示信息
        System.out.print("密　码：");
        // 接收控制台输入的密码
        String pwd = sc.next();
        // 多分支语句
        switch (String.format("%b", user[k][1].equals(pwd))) {
            case "true":// 格式化user[k][1].equals(pwd)的返回值为"true"
                // 提示信息
                System.out.println("------登陆成功------");
                break;
            case "false":// 格式化user[k][1].equals(pwd)的返回值为"false"
                // 提示信息
                System.out.println("----用户信息错误----");
                break;
        }
    }
}

StringBuffer类

创建必须使用new方法，而不是直接赋值，即StringBuffer xxx =new StringBuffer("acv");
appemd();方法可以将任意类型的参数转换成字符串并追加到某字符串序列

输入数字并判断是否为整数

import java.util.Scanner;
public class EvenNumbers {// 偶数类
    public static void main(String[] args) {
        // 创建扫描器对象实现控制台输入
        Scanner sc = new Scanner(System.in);
        // 提示信息
        System.out.print("输入要添加数字的个数：");
        // 接收控制台输入的要添加数字的个数
        int numCounts = sc.nextInt();
        // 创建一个可变字符序列的字符串对象
        StringBuffer sbf = new StringBuffer();
        // 通过循环实现控制台的多次输入并向字符串对象中追加字符串
        for (int i = 1; i <= numCounts; i++) {
            // 提示信息
            System.out.print("第" + i + "个数字：");
            // 接收控制台输入的数字
            int num = sc.nextInt();
            // 如果控制台输入的数字是偶数，向字符串对象中追加字符串
            if (num % 2 == 0) {
                sbf.append(num + " ");
            }
        }
        // 控制台输出字符串对象
        System.out.println("输入数字中的偶数有" + sbf);
        // 关闭控制台输入
        sc.close();
    }
}

setCharAt(,);可以将任意字符串中的字符替换，例如替换手机号中间四位
与replace(start,end,xxxx)类似

StringBuffer phone = new StringBuffer("18996322580")
    for(int i =3 ; i <= 6 ; i ++){
        phone.setCharAt(i,'x');
    }

delete(start,end);方法可以删除某位置的字符串

StringBuffer sbf = new StringBuffer("213123");
sbf.delete(2,3);//为2 =< x < 3

总结

public class StringBufferTest {
    public static void main(String[] args) {
        StringBuffer sbf = new StringBuffer("ABCDEFG"); // 创建字符串序列
        System.out.println("sbf的原值为：" + sbf); // 输出原值
        int length = sbf.length(); // 获取字符串序列的长度
        System.out.println("sbf的长度为：" + length); // 输出长度
        char chr = sbf.charAt(5); // 获取索引为5的字符
        System.out.println("索引为5的字符为：" + chr); // 输出指定索引的字符
        int index = sbf.indexOf("DEF"); // 获取DEF字符串所在的索引位置
        System.out.println("DEF字符串的索引位置为：" + index); // 输出子字符串索引
        String substr = sbf.substring(0, 2); // 截取从索引0开始至索引2之间的字符串
        System.out.println("索引0开始至索引2之间的字符串：" + substr); // 输出截取结果
        // 将从索引2开始至索引5之间的字符序列替换成"1234"
        StringBuffer tmp = sbf.replace(2, 5, "1234");
        System.out.println("替换后的字符串为：" + tmp); // 输出替换结果
    }
}

面向对象编程基础

特点

封装性

封装是面向对象编程的核心思想。将对象的属性和行为封装起来。载体是类。保证了类内部数据结构的完整性，使用该类的用户不能轻易的直接操作此数据结构，只能操作类允许公开的数据。避免了外部操作对内部数据的影响，提高了程序的可维护性。

继承性

继承是实现重复利用的重要手段，子类通过继承，复用父类属性和行为的同时又添加了子类特有的属性和行为。

多态性

将父类对象应用于子类的特征就是多态

类与对象

成员变量

数据类型变量名称 [ = ???]其中[ = ???]可选

成员方法

[权限修饰符] [返回值类型] 方法名([参数类型参数名])[throws 异常类型]{
...//方法体
return 返回值；
}
其中权限修饰符包括： private public protected

例

定义一个showgood()方法，用来输出库存商品信息

public void showgood(){
  System.out.println("name");
  System.out.println(fullname);
}

有返回值

public int showgoood(){
  System.out.println("name:");
  return 1;
}

将美元转换为人民币

public class ExchangeRate { // 创建汇率类
    public static void main(String[] args) {
        ExchangeRate rate = new ExchangeRate(); // 创建RefTest对象
        double[] denomination = { 1, 10, 100 }; // 定义一维数组，用来存储纸币面额（实参）
        // 输出数组中三种面值的美钞
        System.out.print("美元：");
        for (int i = 0; i < denomination.length; i++) { // 使用for循环遍历数组
            System.out.print(denomination[i] + "美元　");
        }
        rate.change(denomination); // 调用方法改变数组中元素的值
        // 输出与三种面值的美钞等值的人民币
        System.out.print("\n人民币：");
        for (int j = 0; j < denomination.length; j++) { // 使用for循环遍历数组
            System.out.print(denomination[j] + "元　");
        }
    }
    // 定义一个方法，方法的参数为一维数组（形参）
    public void change(double[] i) {
        for (int j = 0; j < i.length; j++) { // 使用for循环遍历数组
            i[j] = i[j] * 6.903; // 将数组中的元素乘以当前汇率
        }
    }
}

不定长参数

方法名(参数类型... 参数名)

构造方法

每当实例化一个对象的时候，类都会自动调用构造方法

特点

·没有返回类型，不能定义为void
·名称要与本类名称相同
·完成对象的初始化工作，能把定义对象大的参数传给对象成员

语法

class book{
  public book(){//此括号可以添加参数
  }
}

例

public class BorrowABook { // 创建借书类
    public BorrowABook() { // 无参构造方法
    }
    public void borrow(String name) { // 参数为书名的借书方法
        System.out.println("请前往借阅登记处领取" + name + "。"); // 输出借出的书名
    }
    public static void main(String[] args) {
        BorrowABook book = new BorrowABook(); // 创建借书类对象，
        book.borrow("《战争与和平》"); // 调用借书方法，并将“《战争与和平》”赋给参数name
    }
}

局部变量

在方法执行时候被创建，执行完成后被销毁，使用时必须进行赋值操作或被初始化

this关键字

当类中的成员变量与成员方法中的参数重名时

例：

public class Teacher {
    String name;
    char sex;
    int age;
    public Teacher(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        System.out.println("教师姓名：" + name + "\n教师性别：" + sex + "\n教师年龄：" + age);
    }
    public static void main(String[] args) {
        Teacher chinese = new Teacher("张三", '男', 38);
        Teacher math = new Teacher("李四", '男', 45);
        Teacher english = new Teacher("王莉", '女', 32);
    }
}

除了可以调用类的成员变量和成员方法，还可以调用类中的构造方法

例：

public class Credit {
    String cardNum;
    String password;
    public Credit(String cardNum, String password) {
        this.cardNum = cardNum;
        this.password = password;
        if (password.equals("123456")) {
            System.out.println("信用卡" + cardNum + "的默认密码为" + password);
        } else {
            System.out.println("重置信用卡" + cardNum + "的密码为" + password);
        }
    }
    public Credit(String cardNum) {
        this(cardNum, "123456");
    }
    public static void main(String[] args) {
        Credit initialCredit = new Credit("4013735633800642");
        Credit resetedCredit = new Credit("4013735633800642", "168779");
    }
}

static关键字

静态变量

用于共享变量给不同的类

例

import java.util.Scanner;
public class Account {
    static double rate = 0.0265;
    public void calculateInterest(int principal, int years) {
        double var = 1;
        for (int i = 1; i <= years; i++) {
            var *= (1 + rate);
        }
        double interests = principal * var - principal;
        System.out.println(years + "年后，存入" + principal + "元所获利息为" + String.format("%.3f", interests) + "元RMB。");
    }
    public void changeRate(double newrate) {
        rate = newrate/100;
    }
    public static void main(String[] args) {
        int principal;
        int years;
        Scanner sc = new Scanner(System.in);
        System.out.println("当前银行死期年利率为" + (rate * 100) + "%。\n请输入存款本金：");
        principal = sc.nextInt();
        System.out.println("请输入存款年限：");
        years = sc.nextInt();
        Account oldAccount = new Account();
        oldAccount.calculateInterest(principal, years);
        System.out.println("利率变了！请输入调整后的存款利率（利率格式:2.65）：");
        double changedrate = sc.nextDouble();
        Account newAccount = new Account();
        newAccount.changeRate(changedrate);
        System.out.println("请输入存款本金：");
        principal = sc.nextInt();
        System.out.println("请输入存款年限：");
        years = sc.nextInt();
        newAccount.calculateInterest(principal, years);
        sc.close();
    }
}

静态方法

例

public class Clock {
    String structure;
    String style;
    double price;
    public Clock(String structure, String style, double price) {
        super();
        this.structure = structure;
        this.style = style;
        this.price = price;
    }
    static public void getTime() {
        System.out.println("当前时间：10点10分");
    }
    public static void main(String[] args) {
        Clock bell = new Clock("机械", "钟", 189.99);
        System.out.println(bell.structure + bell.style + "的价格为" + bell.price + "元RMB");
        getTime();
        Clock watch = new Clock("石英", "手表", 69);
        System.out.println(watch.structure + watch.style + "的价格为" + watch.price + "元RMB");
        getTime();
    }
}

静态代码块

public class StaticTest {
    static String name;
    // 静态代码块
    static {
        System.out.println(name + "静态代码块");
    }
    // 非静态代码块
    {
        System.out.println(name + "非静态代码块");
    }
    public StaticTest(String a) {
        name = a;
        System.out.println(name + "构造方法");
    }
    public void method() {
        System.out.println(name + "成员方法");
    }
    public static void main(String[] args) {
        StaticTest s1;// 声明的时候就已经运行静态代码块了
        StaticTest s2 = new StaticTest("s2");// new的时候才会运行构造方法
        StaticTest s3 = new StaticTest("s3");
        s3.method();// 只有调用的时候才会运行
    }
}

运行可以发现
·静态代码块由始至终只运行了一次
·非静态代码块，每次创建对象的时候，会在构造方法前运行，所以读取成员变量name时，只能获取到null
·构造方法只有在使用new创建对象的时候才会运行
·成员方法只有在使用对象调用的时候才会运行
·因为name是static修饰的静态成员变量，在创建s2对象时将字符串‘s2’赋值给了name，所以创建s3对象的时候，重新调用了类的非静态代码块，此时name的值还没有被s3对象改变，于是输出‘s2’非静态代码块

例

public class Year {
    String yearNum;
    public Year(String yearNum) {
        this.yearNum = yearNum;
    }
    static {
        System.out.println("钟声敲响了……\n哪一年的钟声敲响了？");
    }
    public static void main(String[] args) {
        Year year = new Year("2017");
        System.out.println(year.yearNum + "年的。");
    }
}

序言