目录
static关键字
-
static修饰的统一都是静态的，都是类相关的，不需要new对象，直接采用”类名.“访问
/* static: 1、static翻译为：“静态的” 2、所有的static关键字修饰的都是类想关的，类级别的 3、所有static 修饰的，都是采用“类名.”的方式访问 4、static修饰的方法：静态方法 5、static修饰的变量：静态变量 变量的分类： 变量根据声明的位置进行划分： 方法体中声明的变量：局部变量 方法体外声明的变量：成员变量 成员变量又可以分为： 实例变量 静态变量 */ public class StaticText01 { } class VarText{ //以下实例的，都是对象相关的，访问时采用“引用.”的方法访问，需要先new对象 //实例相关的，必须现有对象才能访问，可能会出现空指针异常。 //成员变量中的实例变量 int i; //实例方法 public void m2(){ //局部变量 int x = 200; } //以下静态的，都是类相关的，访问时采用“类名.”的方式访问，不需要new对象。 //不需要对象的参与就可以访问，不会发生空指针异常 //成员变量中的静态变量 static int k; //静态方法 public static void m1(){ int m = 100; } } -
当一个属性是类级别的属性，所有对象的这个属性的值都不会变化时，建议定义为“静态变量”
/* 什么时候变量声明为实例的，什么时候声明为静态的 如果这个类中所有的对象的某个属性都是一样的，不定义为实例变量，太浪费内存空间。 建议定义为类级别特征，定义为静态变量，在方法区中只保留一份，节省内存。 一个对象一份的，定义为：实例变量 每个对象都一样的，定义为：静态变量 */ public class StaticText02 { public static void main(String[] args){ //访问中国人的国籍，country 是静态变量，静态变量应该使用：“类名.”的方式访问 // System.out.println(Chinese.country); Chinese c1 = new Chinese("123456789","张三"); System.out.println(c1.idCard); System.out.println(c1.name); System.out.println(Chinese.country); Chinese c2 = new Chinese("987654321","李四"); System.out.println(c2.idCard); System.out.println(c2.name); System.out.println(Chinese.country); } } //定义country为静态变量 //定义一个类：中国人 class Chinese{ //身份证号 //每个人的省份证号不同，一个对象一个号，所以idCard应该是实例变量。 String idCard; //姓名 //一个人有一个名字，所以name也是实例变量 String name; //国籍 //重点：加static的变量叫做静态变量 //静态变量在类加载时初始化，不需要new对象，静态变量的空间就开创出来 //静态变量存储在方法区 //对于“中国人”这个类来说，国际都是“中国”，不会随着对象的改变而改变 //国籍属于整个类的特征，整个族的特征 //假设声明为静态变量，内存图 static String country = "中国"; //无参数 public Chinese(){ } //有参数 public Chinese(String s1 ,String s2){ idCard = s1; name = s2; } } /* 定义country为实例变量 public class StaticText02 { public static void main(String[] args){ Chinese c1 = new Chinese("123456789","张三","中国"); System.out.println(c1.idCard); System.out.println(c1.name); System.out.println(c1.country); Chinese c2 = new Chinese("987654321","李四","中国"); System.out.println(c2.idCard); System.out.println(c2.name); System.out.println(c2.country); } } //定义一个类：中国人 class Chinese{ //身份证号 //每个人的省份证号不同，一个对象一个号，所以idCard应该是实例变量。 String idCard; //姓名 //一个人有一个名字，所以name也是实例变量 String name; //国籍 //对于“中国人”这个类来说，国际都是“中国”，不会随着对象的改变而改变 //国籍属于整个类的特征，整个族的特征 //假设声明为实例变量，内存图 String country; //无参数 public Chinese(){ } //有参数 public Chinese(String s1 ,String s2,String s3){ idCard = s1; name = s2; country = s3; } } */
-
访问静态变量不会出空指针异常
/* 实例的：一定需要使用：“引用.”的方式访问。 静态的： 使用“类名.”的方式访问，但使用“引用.”的方式也可以访问，但不建议这样使用 静态的如果使用“引用.”的方式访问，会让别人错以为：这个变量是实例变量。 结论： 空指针异常只有什么情况下才会发生呢？ 只要是“空引用”访问“实例相关”时，都会出现空指针异常。 */ public class StaticText03 { public static void main(String[] args){ //通过“类名.”的方式访问静态变量 System.out.println(Chinese1.country);//中国 //创建对象 Chinese1 c1 = new Chinese1("123456","张三"); System.out.println(c1.idCard);//123456 System.out.println(c1.name);//张三 System.out.println(c1.country);//中国 c1 = null; //分析这里会不会出现空指针异常 System.out.println(c1.country);//中国 //没有出现空指针异常，因为静态变量不需要对象的存在 //实际以上代码在运行时，还是：System.out.println(Chinese1.country); System.out.println(c1.name); //这个还是会出现空指针异常，因为name是实例变量。对象为空，空引用访问，所以出现空指针异常 } } class Chinese1{ //实例变量 String idCard; String name; //静态变量 static String country = "中国"; //构造方法 public Chinese1(String x , String y){ idCard = x; name = y; } } -
实例方法的调用
public class StaticText04 { public static void main(String[] args){ //静态方法的访问，正规：类名. StaticText04.doSome(); //创建对象 StaticText04 st = new StaticText04(); //用“引用.”访问 st.doSome(); //空引用访问静态方法 st = null; //访问静态方法永远不会出现空指针异常 st.doSome();//这个代码在运行时会转变为:StaticText04.doSome(); //实例方法doOther(); //对象级别的方法(先new对象，通过“引用.”的方式访问) //StaticText04.doOther(); //编译报错 //无法从静态上下文中引用非静态 方法 doOther() StaticText04 st2 = new StaticText04(); st2.doOther(); //空引用访问实例方法 st2 = null; //空引用调用实例方法会出现：空指针异常。 //st2.doOther(); } //静态方法 (静态方法不需要new对象，直接使用“类名.”来访问) public static void doSome(){ System.out.println("静态方法doSome()执行了！"); } //实例方法(实例相关的都需要new对象，只能使用“引用.”来访问。) public void doOther(){ System.out.println("实例方法doOther()执行了"); } } /* 类{ //实例相关的都是需要new对象的，通过“引用.”访问 实例变量 实例方法 //静态相关都是通过“类名.”访问。也可以通过“引用.”访问，但是用过引用访问会让别人误会这是个实力变量，所以一般不推荐使用 静态变量 静态方法 } */ -
什么时候定义为实例方法，什么时候定义为静态对象。
/* 关于方法来说，什么时候定义为实例方法，什么时候定义为静态方法 此方法一般都是描述了一个行为，如果说该行为必须去由对象去触发，那么该方法定义为实例方法。 标准：当一个方法体当中，直接访问了实例变量，这个方法一定是实例方法。 以后的开发中，大部分情况下，如果是工具类的话，工具类当中的方法一般都是静态的。 (静态方法有一个优点，是不需要new对象，直接采用类名调用，很方便) (工具类就是为了方便，所以工具类中的方法一般都是static的) 工具类就是为了方便编程而开发的一些类。 什么时候方法定义为实例方法？ 张三考试，得分90 李四考试，得分100 不同的对象参加考试的结果不同 我们可以认定“考试”这个行为是与对象相关的。 建议将“考试”这个方法定义为实例方法 类=属性+方法 属性描述的是：状态 方法描述的是：行为/动作 */ public class StaticText05 { public static void main(String[] args){ User2 u = new User2(); System.out.println(u.getId()); //0 } } class User2{ //实例变量，需要对象 private int id; // public void setId(int i){ id = i; } public int getId(){ return id; } } -
静态代码块
/* 1、使用static关键字可以定义“静态代码块” 2、什么是静态代码块，语法是什么？ static { java语句; java语句; } 3、static静态代码块在什么时候执行呢？ 类加载时执行。并且只执行一次。 静态代码块有这样的特征/特点。 4、注意：静态代码块在类加载时执行，并且在main方法执行之前执行。 就算是写在main方法之后，也是先执行静态代码块。 5、静态代码一般是自上而下的顺序执行。 6、静态代码块有什么用？ 第一：静态代码块不是那么常用。(不是每一个类当中都要写的东西) 第二：静态代码块这种语法机制实际上是SUN公司给我们java程序员的一个特殊的时刻/时机 这个时机叫做：类加载时机。 具体的业务： 项目经理说了：大家注意，所有编写的程序，只要是类加载了，请记录一下类加载的日志信息 在哪年哪月哪日几时几分几秒 ，哪个类加载到JVM当中了。 */ public class StaticText06 { //静态代码块(特殊的时机：类加载时机。) //一个类当中可以编写多个静态代码块，但一般不会写多个，一般只写一个静态代码块 static{ System.out.println("aaa"); } static{ System.out.println("bbb"); } //入口 public static void main(String[] args){ System.out.println("Hello World"); } static{ System.out.println("ccc"); } } -
类加载时代码执行的先后顺序为 自上而下。
/* 栈：方法只要执行，都会压栈。（局部变量 存储在 栈 ） 堆：new 出来的对象都在堆中。垃圾回收器主要针对堆中的垃圾数据 （实例变量 存储在 堆 ） 方法区：类的信息，字节码信息，代码片段 （静态变量 存储在 方法区 ） */ public class StaticText07 { //静态变量存储在 方法区 ，在类加载时 初始化， static int i = 100; //静态代码块在类加载时执行 static{ //这里可以访问静态变量i吗 //可以，因为都是在类加载时进行的 System.out.println("i="+i); } //实例变量 int k = 111; static{ //这里可以访问实例变量k吗？ //System.out.println("k= " + k);//报错：无法从静态上下文中引用非静态 变量 k、 //实例变量在 构造方法执行时（new对象）进行初始化 } /* //静态变量在静态代码块下时，可以在静态代码块中访问name吗？ //不可以，静态代码块 和 静态变量初始化 都在 类加载的时候 自上而下 执行，谁靠前谁先执行 static{ System.out.println("name=" +name); //报错: 非法前向引用 } static String name = "eee"; */ //入口(main方法执行之前实际上执行了很多代码) public static void main(String[] args){ } } /* 总结： 到目前为止，你遇到的所有java程序，有顺序要求的是哪些？ 第一：对于一个方法来说，方法体中的代码是有先后顺序的，遵循自上而下的顺序执行 第二：静态代码块和静态变量是有先后顺序的 第三：静态代码块1和静态代码块2是有先后顺序的。 */ -
实例语句块
/* 1、除了静态代码块之外，还有一种语句叫做：实例语句块。 2、实例语句在类加载时并不执行 3、实例语句语法： { java语句; java语句; java语句; } 4、实例语句块在什么时候执行？ 只要是构造方法执行，必然在构造方法执行之前，自动执行“实例语句块”中的代码 实际上这也是SUN公司为java程序员准备的一个特殊的时机，叫做：对象创建时机。 5、实例语句块也可以写多个，但一般只写一个。 */ public class InstanceCode { public static void main(String[] args){ System.out.println("main begin!"); new InstanceCode(); new InstanceCode(); new InstanceCode("abc"); } //实例语句块 { System.out.println("实例"); } public InstanceCode(){ System.out.println("无参数的构造方法执行"); } public InstanceCode(String name){ System.out.println("有参数的构造方法执行"); } //尽管实例语句块在构造方法的下面，但也是在构造方法执行之前执行。 { System.out.println("实例语句块执行了!"); } } -
判断以下代码的执行顺序
/* 判断以下代码的执行顺序 静态代码块在类加载时执行——>方法执行——>调用构造方法——>实例语句块执行——>构造方法执行 */ public class CodeOrder { //静态代码块 static{ System.out.println("1AAA");//1 } //入口 public static void main(String[] args){ System.out.println("3EEE");//3 new CodeOrder(); System.out.println("6FFF");//6 } //构造方法 public CodeOrder(){ System.out.println("5BBB");//5 } //实例语句块 { System.out.println("4CCC");//4 } //静态代码块 static{ System.out.println("2DDD");//2 } }
this关键字
- this是一个关键字，是一个引用，保存内存地址，指向自身。
- this可以使用在实例方法中，也可以使用在构造方法中
- this出现在实例方法中，代表的是当前对象
- this不能使用于静态方法
- this. 大部分情况下可以省略，但是用于区分局部变量和实例变量时不能省。
- this()这种语法只能出现在构造方法的第一行，表示当前构造方法调用本类中另一个构造方法，目的：代码复用
/*
this 关键字：
1、this是一个关键字，全部小写。
2、this是什么？在内存方面是怎么样的？
一个对象一个this
this是一个变量，是一个引用。this保存当前对象的内存地址，指向自身。
严格意义上说:this代表的就是“当前对象”，this存储在堆内存当中对象的内部
3、this只能用在实例方法中，谁调用这个方法，this就是谁
所以this代表的是：当前对象。
4、“this”大部分情况是可以省略的
5、为什么this不能使用在静态方法中
this代表当前对象，静态方法中不存在当前对象。
*/
public class ThisText01 {
public static void main(String[] args){
Customer1 c1 = new Customer1("张三");
c1.Shoopping();
Customer1 c2 = new Customer1("李四");
c2.Shoopping();
}
}
//顾客类
class Customer1{
//属性
//实例变量（必须采用“引用.”的方式访问）
String name;
//构造方法
public Customer1(){}
public Customer1(String s){
name = s;
}
//顾客购物的方法
//实例方法
public void Shoopping(){
//这里的this就是：当前对象
//c1调用shopping()，this是c1
//c2调用shopping()，this是c2
//System.out.println(this.name+"正在购物！");
//this.是可以省略的。
//this.省略的话，还是默认访问“当前对象”的name
System.out.println(name+"正在购物！");
}
//静态方法
public static void doSome(){
//this代表的是当前对象，而静态方法的调用不需要对象，矛盾了
//错误：无法从静态上下文中引用非静态 变量 this
//System.out.println(this);
}
}
class Student2{
String name = "zhangsan";
public static void m1(){
//System.out.println(name);
//this代表的是当前对象。
//System.out.println(this.name);
//除非你这样
Student2 s = new Student2();
System.out.println(s.name);
}
//为什么set和get方法是实例方法
public String getName(){
return name;
}
public void setName(String s){
name = s;
}
//什么时候方法定义为实例方法，什么时候方法定义为静态方法？
//如果方法中直接访问了实例变量，该方法必须是实例方法。
}
//分析i在main方法中能不能访问
public class ThisText02 {
//实例变量
int i = 100;
//静态变量
static int k = 111;
//静态方法
public static void main(String[] args){
//错误: 无法从静态上下文中引用非静态 变量 i
//System.out.println(i);
//因为i是实例变量，所以要通过：引用.的方式访问。
ThisText02 t = new ThisText02();
System.out.println(t.i);
//静态变量用“类名.”访问
System.out.println(ThisText02.k);
//类名.可以省
System.out.println(k);
}
}
this作业1
/*
第五题：定义丈夫类 Husband 和妻子类 Wife，
丈夫类的属性包括：身份证号，姓名，出生日期，妻子。
妻子类的属性包括：身份证号，姓名，出生日期，丈夫。
分别给这两个类提供构造方法（无参数构造方法和有参数构造方法都要提供），
编写测试程序，创建丈夫对象，然后再创建妻子对象，丈夫对象关联妻子对象，
妻子对象关联丈夫对象，要求能够输出这个“丈夫对象”的妻子的名字，
或执行者能够输出这个“妻子对象”的丈夫的名字。要求能够画出程序过程的内存图。
并且要求在程序中演示出空指针异常的效果。
总结：类名/引用
.后面只是一个单词，没有小括号，表示访问的是属性
.后面有一个单词，单词后面有小括号，表示访问的是方法
*/
public class Work001 {
public static void main(String[] args){
//创建丈夫对象
Husband hu = new Husband("123456","张三","2000-10-23",null);
//创建妻子对象
Wife wi = new Wife("654321","李四","2000-01-30",null);
//让他们结婚
//这里如果不结婚，通过丈夫找妻子名字时，会出现空指针异常，因为丈夫的妻子为null了，所以出现空指针异常
hu.wife = wi;
wi.husband = hu;
//输出丈夫对象妻子的名字
//这里不能直接用妻子的名字，可能他们不匹配，没结婚。必须是找妻子的名字
System.out.println(hu.name+"de qi zi shi :"+ wi.name);
//这里找妻子的名字是从丈夫里先找妻子，找到妻子后再去找妻子的名字
System.out.println(hu.name+"的妻子是："+hu.wife.name);
System.out.println(wi.name+"的丈夫是："+wi.husband.name);
}
}
//丈夫类
class Husband{
//身份证号
String idCard;
//姓名
String name;
//生日
String birth;
//妻子
Wife wife;//这里是引用数据类型。
public Husband(){
}
public Husband(String s1,String s2 ,String s3,Wife w){
idCard = s1;
name = s2;
birth =s3;
wife = w;
}
/* 有参数的构造方法也可以这样写
public Husband(String s1,String s2 ,String s3){
idCard = s1;
name = s2;
birth =s3;
//wife = null;//这里为变量赋默认值：null
}
*/
}
//妻子类
class Wife{
//身份证号
String idCard;
//姓名
String name;
//生日
String birth;
//丈夫
Husband husband;
public Wife(){
}
public Wife(String s1,String s2 ,String s3,Husband h){
idCard = s1;
name = s2;
birth =s3;
husband = h;
}
}
this作业2
/*
一、请通过代码封装，实现如下需求：
编写一个类Book，代表教材:
1.具有属性：名称（title）、页数（pageNum）
2.其中页数不能少于200页，否则输出错误信息，并赋予默认值200
3.为各属性提供赋值和取值方法
4.具有方法:detail，用来在控制台输出每本教材的名称和页数
5.编写测试类BookTest进行测试：为Book对象的属性赋予初始值，并调用Book对象的detail方法，看看输出是否正确
*/
public class Work002 {
public static void main(String[] args){
//创建Book对象
Book b1 = new Book("高三数学人教版",250);
//调用 detail 方法
b1.detail();
//修改页数
b1.setPageNum(100);
b1.detail();
Book b2 = new Book();
b2.detail();
/*
这里出现——————教材名称：null的页数是：0
解决方案：
1、把无参数的构造方法删掉
2、在无参数的构造方法中给他赋值代替系统赋的默认值
*/
}
}
class Book{
//题目要求封装，所以这里设置变量为私有的。
private String title;
private int pageNum;
//无参以及有参构造方法
public Book(){
title = "weizhi ";
pageNum = 200;
}
public Book(String s,int i){
//或者在这里也可以对页数不足的进行错误判断
title = s;
if(i<200){
System.out.println("错误");
//默认赋值200
pageNum = 200;
}else{
pageNum = i;
}
}
//set 以及 get 构造方法
public String getTitle(){
return title;
}
public void setTitle(String s){
title = s;
}
public int getPageNum(){
return pageNum;
}
public void setPageNum(int i){
if(i< 200){
System.out.println("错误");
//默认赋值200
pageNum = 200;
return;//结束该方法
}
//可以执行到这里说明页数大于等于200的，直接赋值
pageNum = i;
}
//额外提供一个detail方法
//这里不能加static ，因为里面的title与pageNum都是实例变量，所以要把detail定义为实例方法。
//然后创建对象后再调用此方法。
public void detail(){
System.out.println("教材名称："+title +"的页数是："+ pageNum);
}
}
this什么时候不可以省略
/*
1、this可以使用在实例方法中，不能使用在静态方法中
2、this关键字大部分情况下可以省略，什么时候不能省略呢？
在实例方法、构造方法中，为了区分局部变量以及实例变量。
这种情况下:this.是不可以省略的。
*/
public class ThisText03 {
public static void main(String[] args){
Student3 s = new Student3();
s.setNo(111);
s.setName("张三");
System.out.println("学号："+s.getNo());
System.out.println("姓名："+s.getName());
Student3 s2 = new Student3(222,"李四");
System.out.println("学号："+s2.getNo());
System.out.println("姓名："+s2.getName());
}
}
//分析以下代码，看哪里设置的不好
//学生类
class Student3{
//学号、姓名
private int no;
private String name;
//构造方法
public Student3(){}
/*
public Student3(int i,String s){
no = i;
name = s;
}
*/
//这里也可以这样改，增强可读性。
public Student3(int no,String name){
this.no = no;
this.name = name;
}
//set 和 get 方法
//方法中i、s可读性差，
public int getNo(){
return no;
//return this.no; //这里实际上是这样写的。
}
/*
public void setNo(int i){
no = i;
}
*/
/*
public void setNo(int no){//就近原则
no = no; //这里的两个no都是局部变量no，和实例变量no没有关系。
}
*/
//这个时候就用到this，this.的作用：区分局部变量和实例变量
public void setNo(int no){
//no是局部变量，this.no是实例变量
this.no = no;// 当前对象的no = no; 后面这个no是赋值进来的
}
public String getName(){//getName实际上获取的是“当前对象”的名字
//return this.name; //严格来说，这里的代码实际上是有this.的，不过这里的this.可以省
return name;
}
/*
public void setName(String s){
name = s;
}
*/
/*
public void setName(String name){//就近原则
name = name; //这里的两个name都是局部变量name，和实例变量name没有关系
}
*/
public void setName(String name){
this.name = name;
}
}
java中变量的存储位置
this可以用于构造方法中
/*
1、this除了可以用在实例方法中，还可以用在构造方法中。
2、新语法：通过当前的构造方法去调用另一个本类中的构造方法，可以使用以下语法格式：
this(实际参数列表);
通过一个构造方法去调用另一个构造方法，可以做到代码复用
注意：两个构造方法必须在同一个类当中。
3、this()这个语法的作用：代码复用
4、对于this()的调用只能出现在构造方法的第一行。
*/
public class ThisText04 {
public static void main(String[] args){
//调用无参数构造方法
Date d1 = new Date();
d1.detail();
Date d2 = new Date(2020,11,22);
d2.detail();
}
}
/*
需求：
1、定义一个日期类，可以表示年月日信息
2、如果调用无参的构造方法，默认创建日期为：1970/01/01，也可以用有参的构造方法创建日期对象
*/
class Date{//以后写代码都要封装，属性私有化，对外提供set get方法
private int year;
private int month;
private int day;
//构造方法
public Date(){
//错误:: 对this的调用必须是构造器中的第一个语句
//System.out.println("1");
//这里的this.可以省略
/*
this.year = 1970;
this.month = 1;
this.day = 1;
这三行代码可以用以下一行代替。
*/
this(1984,1,1);
}
public Date(int year , int month , int day){
this.year = year;
this.month = month;
this.day = day;
}
//打印日期的方法
public void detail(){
System.out.println(year + "年" + month +"月" + day + "日");
}
//set get 方法
public int getYear(){
return year;
}
public void setYear(int year){
this.year = year;
}
public int getMonth(){
return month;
}
public void setMonth(int month){
this.month = month;
}
public int getDay(){
return day;
}
public void setDay(){
this.day = day;
}
}
综合作业1
/*
二、写一个名为Account的类模拟账户。
该类的属性和方法如下所示。
该类包括的属性：账户id，余额balance，年利率annualInterestRate；
包含的方法：各属性的set和get方法。取款方法withdraw()，存款方法deposit()
写一个测试程序
（1）创建一个Customer，名字叫Jane Smith，他有一个账号为1000，余额为2000，年利率为1.23%的账户
（2）对Jane Smith操作：
存入100元，再取出960元，再取出2000。
打印Jane Smith的基本信息
信息如下显示：
成功存入：100
成功取出：960
余额不足，取钱失败
Customer [Smith，Jane] has a account ：id is 1000 annualInterestRate is 1.23% balance is 1140.0
*/
public class ThisHomework {
public static void main(String[] args){
//先创建一个账户
Account a = new Account(1000,2000,1.23);
//创建客户对象
//传给构造方法a，让Customer2对象与Account对象产生关系
//表示a这个账户是Smith的。 先创建账户，然后传给客户
Customer2 c = new Customer2("Jane Smith",a);
//这里因为封装，所以要用get方法去读取act账户
//而通过getAct()方法读取的账户实际上就是账户a，但是因为属性私有化，不能c.a.deposit(100);这样去读改。
// c.a.deposit(100);
// c.a.withdraw(960);
// c.a.withdraw(2000);
c.getAct().deposit(100);
c.getAct().withdraw(960);
c.getAct().withdraw(2000);
}
}
//以后都是封装，所有的类都是属性私有化，对外提供set和get方法。
class Customer2{
//名字
private String name;
//银行账户，这里是引用数据类型。
private Account act;
//构造方法
public Customer2(){}
public Customer2(String name , Account act){
this.name = name;
this.act = act;
}
//get set 方法
//为什么要写set和get？用的着吗？ 用不着也得写，因为这是“封装”规定的。
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public Account getAct(){
return act;
}
public void setAct(Account act){
this.act = act;
}
}
class Account{
private int id;
private double balance;
private double annualInterestRate;
//构造方法
public Account(){}
public Account(int id,double balance,double annualInterestRate){
this.id = id;
this.balance = balance;
this.annualInterestRate = annualInterestRate;
}
//set get方法
//这里set方法是为了以后修改属性时候可以直接修改。
public int getId(){
return id;
}
public void setId(int id){
this.id = id;
}
public double getBalance(){
return balance;
}
public void setBalance(double balance){
this.balance = balance;
}
public double getAnnualInterestRate(){
return annualInterestRate;
}
public void setAnnualInterestRate(double annualInterestRate){
this.annualInterestRate = annualInterestRate;
}
/*
//存款方法
public void deposit(double money){//钱这里设置为浮点类型，余额也是浮点类型的，钱不一定都是整数。
//这里的this.可以省，但是这个方法实际上是实例方法，还是加上的好
this.balance += money;
System.out.println("成功存入："+money);
}
//取款方法
public void withdraw(double money){
if (money<this.balance){
this.balance -= money;
System.out.println("成功取出："+money);
}else{
System.out.println("余额不足，取钱失败");
}
}
//取款方法也可以这样写
// public void withdraw(double money){
// if (money<this.balance){
// this.balance -= money;
// System.out.println("成功取出："+money);
// return;//成功取出后结束方法，不再运行。
// }
// System.out.println("余额不足，取钱失败");
// }
*/
//也可以调用set方法以及get方法 进行改查
//存款
public void deposit(double money){
//调用方法
this.setBalance(this.getBalance()+money);
System.out.println("成功存入："+money);
}
//取款
public void withdraw(double money){
if (money>this.balance){
System.out.println("余额不足，取钱失败");
return;//余额不足结束方法，不会再运行下面的命令
}
this.setBalance(this.getBalance()- money);
System.out.println("成功取出："+money);
}
}
综合作业2
/*
三、(封装)已知一个类 Student 代码如下：
class Student{
String name;
int age;
String address;
String zipCode;
String mobile;
}
要求：
1、把Student 的属性都作为私有，并提供get/set 方法以及适当的构造方法。
2、为Student 类添加一个getPostAddress 方法，要求返回Student 对象的地址和邮编。
*/
public class ThisHomework2{
public static void main(String[] args){
Student4 s1 = new Student4();
System.out.println(s1.getName()+"的"+s1.getPostAddress());
//赋值
s1.setName("张三");
s1.setAge(18);
s1.setAddress("北京朝阳区");
s1.setZipcode("121212");
s1.setMobile("15896542365");
System.out.println(s1.getName()+"的"+s1.getPostAddress());
Student4 s2 = new Student4("李四",130,"西天","147852","14785236985");
System.out.println(s2.getName()+"的"+s2.getPostAddress());
}
}
class Student4{//private修饰的东西在本类中是可以访问的。
private String name;
private int age;
private String address;
private String zipcode;
private String mobile;
//构造方法
public Student4(){}
public Student4(String name,int age,String address,String zipcode,String mobile){
this.name = name;
this.age = age;
this.address = address;
this.zipcode = zipcode;
this.mobile = mobile;
}
//get set 方法
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public String getAddress(){
return address;
}
public void setAddress(String address){
this.address =address;
}
public String getZipcode(){
return zipcode;
}
public void setZipcode(String zipcode){
this.zipcode = zipcode;
}
public String getMobile(){
return mobile;
}
public void setMobile(String mobile){
this.mobile = mobile;
}
public String getPostAddress(){
return "地址："+this.getAddress() + "\t邮编:"+this.getZipcode();
//return "地址："+this.address + "\t邮编:"+this.zipcode;
}
}
总结：
/*
类体{
实例变量;
实例方法;
静态变量;
静态方法;
构造方法;
静态代码块;
实力语句块;
方法(){
//局部变量
int i = 100;
}
}
*/
public class review {
//类加载机制中，是这样的：在程序执行之前，凡是需要加载的类全部加载到JVM中
//先完成类加载才会执行main方法。
static{
System.out.println("类加载时执行");
}
//静态方法 //程序入口
public static void main(String[] args){
//局部变量
int i = 100;
//完成一个对象的一连串动作
//一个学生先在教室学习，学习完成之后去餐厅吃饭。
Student5 s1 = new Student5();
s1.study();
Student5 s2 = new Student5();
}
}
//学生类
class Student5{
static{
System.out.println("student类执行。");
}
//实例变量
//私有的在本类中可以访问，其它类中必须使用set和get方法。
private int no;
private String name;
//静态变量
//类级别的属性
static String job = "学习";
{
System.out.println("实例语句块，构造方法每执行一次，这个就执行一次");
}
//构造方法
public Student5(){
//假设调用无参构造方法，默认为：学号100，名字张三
this(100,"张三");//this()在这里使用了。
}
public Student5(int no,String name){
this.no = no;//这里使用了this
this.name = name;
}
//封装
//set get方法
public int getNo(){
return no;
}
public void setNo(int no){
this.no = no;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
//提供两个实例方法
public void study(){
// System.out.println(this.name + "正在努力学习");
// System.out.println(name + "正在努力学习");
//在实例方法中调用本类中其他方法。
// System.out.println(this.getName() + "正在努力学习");
System.out.println(getName() + "正在努力学习");
//学习完去干饭，执行到这里是学习完了
//this.eat();//调用eat()方法， 这里的this.方法可以省
//编译器检测到eat()方法是实例方法，会自动在eat()方法前添加this.
eat();
}
public void eat(){
System.out.println(this.getName()+"在餐厅干饭");
//这里调用静态方法m1()
//静态方法使用“类名.”方式访问，在同一个类中“类名.”可以省
// Student5.m1();
//java编译器会自动在m1()方法钱添加“类名.”，因为检测到m1()方法是一个静态方法。
m1();
}
//提供两个静态方法
public static void m1(){
System.out.println("Student's m1 method execute");
//调用m2方法
m2();
}
public static void m2(){
System.out.println("Student's m2 method execute");
System.out.println("工作性质："+job);
//编译器检测到job是一个静态变量，所以这里会自动在job前添加：Student5.
//System.out.println("工作性质:"+Student5.job);
}
}
/*
程序再怎么变化，万变不离其宗，有一个固定的规律：
所有的实例相关的都是先创建对象，通过“引用.”来访问。
所有的静态相关的都是直接采用“类名.”来访问。
大结论：
在一个方法中调用另一个方法，只要这两个方法在同一个类中：
this. 和 类名. 就可以省略
反之:
静态方法要加类名.
实例方法要先new对象，然后通过this.访问。
*/
public class review2 {
int i = 100;
static int j = 2000;
public void m1(){}
public void m2(){}
//实例方法
public void x(){//这个方法是实例方法，执行这个方法的过程中，当前对象是存在的。
m1();
m2();
m3();
m4();
//t1是另一个类中的一个静态方法，可以通过类名.访问
T1.t1();
//t2是另一个类中的实例方法，先创建对象才能访问。
//这两种方式都是错误的。
// T1.t2();
// t2();
T1 t = new T1();
t.t2();
System.out.println(i);
System.out.println(j);
}
public static void m3(){}
public static void m4(){}
/*
分析：
1、main方法是静态的，JVM调用main方法的时候直接采用的是“类名.”的方式，所以main方法中没有this.
2、m1()和m2()都是实例方法，按照规则：实例方法必须先new对象再通过“引用.”的方式访问。
*/
public static void main(String[] args){
//报错：无法从静态上下文中引用非静态 方法
// m1();
// m2();
m3();
m4();
//错误:无法从静态上下文中引用非静态 变量 i
//System.out.println(i);
System.out.println(j);
//想要访问m1()、m2()和i，必须先new对象。
review2 r = new review2();
System.out.println(r.i);
r.m1();
r.m2();
//局部变量,访问时不需要类名.
int k = 10000;
System.out.println(k);
}
}
class T1{
public static void t1(){}
public void t2(){}
}
