编写年级类 属性:年级编号、年级名称、年级地址 构造方法:无参、带参 方法:输出年级的所有信息
package com.bjpowernode.demo1;
/**
* 编写年级类
* 属性:年级编号、年级名称、年级地址
* 构造方法:无参、带参
* 方法:输出年级的所有信息
*
*/
public class Grade {
//属性也叫做成员变量或者字段f
int id; //表示年级编号
String name;
String address;
//构造方
public Grade() {
}
public Grade(int id, String name, String address) {
this.id = id;
this.name = name;
this.address = address;
}
//方法:输出年级的所有信息
public void print(){
System.out.println("年级编号:" + id + "\n年级名称:" + name + "\n年级地址:" + address);
}
}
编写学生类 属性:学号、姓名、年龄、性别、年级 构造方法:无参、带参 方法:输出学生的所有信息(学号、姓名、年龄、性别、年级名称、年级地址)
package com.bjpowernode.demo1;
/**
* 编写学生类
* 属性:学号、姓名、年龄、性别、年级
* 构造方法:无参、带参
* 方法:输出学生的所有信息(学号、姓名、年龄、性别、年级名称、年级地址)
*
*/
public class Student {
//编写属性
int stuNum;
public String stuName;
int stuAge;
char stuGender;
Grade stuGrade; //默认值为null
//构造方法
public Student() {
}
public Student(int stuNum, String stuName, int stuAge, char stuGender, Grade stuGrade) {
this.stuNum = stuNum;
this.stuName = stuName;
this.stuAge = stuAge;
this.stuGender = stuGender;
this.stuGrade = stuGrade;
}
//方法:输出学生的所有信息(学号、姓名、年龄、性别、年级名称、年级地址)
public void print(){
System.out.println("学号:" + stuNum);
System.out.println("姓名:" + stuName);
System.out.println("年龄:" + stuAge);
System.out.println("性别:" + stuGender);
/*
注意:当年级属性stuGrade没有赋值,则是null默认值,此时就不能再去访问对象中的属性或方法,如果非要访问则就出现空指针异常
解决办法:在调用属性或方法之前必须要先进行判断,如果年级属性名stuGrade中存放的是null,则就表示没有存放对象的地址,直接输出null,就不需要调用对象中的属性或方法,否则表示stuGrade属性中存放地址,则就可以调用对象中的属性或方法
则使用三目运算符完成
但是运行后发现依然出现空指针异常,则必须将三目运算符括起来
*/
System.out.println("年级名称:" + (stuGrade == null ? null : stuGrade.name));
System.out.println("年级地址:" + (stuGrade == null ? null :stuGrade.address));
}
}
测试类
package com.bjpowernode.demo1;
public class Test {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//并调用方法输出学生的所有信息
s.print();
System.out.println("-----------------------");
//创建学生对象同时执行带参构造方法
s = new Student(02012, "小张", 24, '男',new Grade(2013, "Java工程师", "北京市"));
//其实上面一条语句也可以编写为如下代码
/*Grade g = new Grade(2013, "Java工程师", "北京市");
s = new Student(2012, "小张", 24, '男', g);*/
s.print();
}
}
1.this关键字可以访问本类(当前类)中的实例变量
package com.jian.demo3;
/**
* 1.this关键字可以访问本类(当前类)中的实例变量
* 1.变量:存放数据的,并且存放的数据是可以发生改变的
* 实例变量也就是对象的变量:也就是属性(成员变量、字段)没有使用static关键字修饰
* 静态变量也叫做类的变量:也就是属性(成员变量、字段)使用static关键字修饰
* 2.实例变量什么时候存在?
* 当创建对象时,会在堆内存的对象中存放,因此也叫做对象的变量
* 3.当局部变量没有与实例变量同名,则可以在本类(当前类)中直接使用实例变量,其实默认前面添加this.
* 比如:brand其实等价于this.brand
* 4.在同一个类中,局部变量的名字可以与实例变量同名,不报错,但是局部变量优先也就是就近的优先,如果非要访问实例变量则必须使用this.
*
*/
public class Computer {
//编写实例变量也就是对象的变量
String brand;
int price;
double size;
//编写方法
public void print(){
//3当局部变量没有与实例变量同名,则可以在本类(当前类)中直接使用实例变量,其实默认前面添加this.
System.out.println(brand); //等价于this.brand
System.out.println(price); //等价于this.price
System.out.println(size); //等价于this.size
}
public void print2(){
//4.在同一个类中,局部变量的名字可以与实例变量同名,不报错,但是局部变量优先也就是就近的优先,如果非要访问实例变量则必须使用this.
String brand = "acer"; //brand就是局部变量
System.out.println("输出实例变量品牌的值:" + this.brand);
System.out.println("输出局部变量品牌的值:" + brand);
}
}
测试类
package com.jian.demo3;
public class Test {
public static void main(String[] args) {
//创建电脑对象
Computer c = new Computer();
c.print();
Computer computer = new Computer();
computer.print();
c.print2();
computer.print2();
}
}
2.this关键字可以访问本类(当前类)中的实例方法
package com.jian.demo4;
/**
* 2.this关键字可以访问本类(当前类)中的实例方法
* 2.1实例方法也就是对象的方法:其实就是在方法前面没有编写static关键字
* 静态方法也就是类的方法:其实也就是在方法中使用static关键字修饰
* 2.2在同一个类中,实例方法之间是可以相互直接调用,也就是默认前面添加this.
*
*/
public class Computer {
//实例方法也叫做对象的方法
public void print(){
}
public void print2(){
this.print(); //等价于print();
}
}
测试类
package com.jian.demo4;
public class Test {
public static void main(String[] args) {
Computer c1 = new Computer();
c1.print2();
Computer c = new Computer();
c.print2();
}
}
3.this关键字可以访问本类中的其他构造方法
package com.jian.demo5;
/**
* 3.this关键字可以访问本类中的其他构造方法
* 调用本类中的构造方法,则使用this关键字
* ---如果this后面的小括号中没有内容,则执行无参构造方法
* ---如果this后面的小括号中有内容,则执行带参构造方法
* 注意事项:1.当使用this关键字调用本类的构造方法时,必须编写在构造方法中,并且是第一条语句
* 2.当使用this关键字调用构造方法时,不能构造方法自己调用自己,也就是递归调用,也就是死循环,没有意义
*
*/
public class Computer {
//编写实例变量
String brand;
String color;
int price;
double size;
//构造方法
public Computer() {
}
public Computer(String brand, int price) {
this.brand = brand;
this.price = price;
}
public Computer(String brand, String color, int price, double size) {
/*this.brand = brand;
this.price = price;*/
/*
其实上面两条语句,也可以编写调用本类中的带两个参数的构造方法,完成对品牌和价格
调用本类中的构造方法,则使用this关键字
---如果this后面的小括号中没有内容,则执行无参构造方法
---如果this后面的小括号中有内容,则执行带参构造方法
注意事项:1.当使用this关键字调用本类的构造方法时,必须编写在构造方法中,并且是第一条语句
2.当使用this关键字调用构造方法时,不能构造方法自己调用自己,也就是递归调用,也就是死循环,没有意义
*/
this(brand, price);
this.color = color;
this.size = size;
}
//编写方法,输出电脑的所有信息
public void print(){
System.out.println("品牌:" + this.brand + "\n颜色:" + this.color + "\n价格:" + this.price + "\n尺寸:" + this.size);
}
}