序言
一周或两周前买了从零学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 + "年的。");
}
}
[…] java学习笔记(一) […]