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;

运算优先级

  1. ()
  2. + - //此为正负号
  3. ++ -- !
  4. * / %
  5. + -
  6. >> << >>>
  7. > < = >= <=
  8. == !=
  9. &
  10. ^
  11. |
  12. &&
  13. ||
  14. ? :
  15. = //赋值

流程控制

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

判断

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"
			   	   + "      |  \\ `\\      /`/ \\\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 + "年的。");
	}
}


核心技术

面向对象核心技术

类的封装

1 thought on “java学习笔记(一)

  1. Pingback: java学习笔记(二) – Ha1c9on

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注

Protected with IP Blacklist CloudIP Blacklist Cloud