就近原则:
类中的方法中的变量和成员变量重名时,调用类的方法时候,生效的是方法中的变量,如果方法中没有定义变量,才会去成员变量中寻找
于是,提出了this关键字,为了区分重名问题
public class Person {
// 人的姓名年龄,成员变量
private String name;
private int age;
public void setAge(int a) {
if (a < 0 || a > 100) {
age = 20;
} else {
age = a;
}
}
public void setName(String n){
name = n;
}
//定义方法,获取age
public int getAge(){
return age;
}
public String getName(){
return name;
}
// 说话功能
public void speak() {
String name = "李四";
int age = 16;
System.out.println(this.age + "岁的" + this.name + "在说话");
}
}public class PersonTest {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
p.setAge(80);
System.out.println(p.getAge());
System.out.println(p.getName());
p.speak();
}
}这里如果不写this,输出的就是李四,如果写了则输入张三
注意this是调用者本身的对象
this内存分析:
1.main进栈运行,堆中开空间存入Person对象,成员变量跟随并赋默认值
2.p调用speak方法时,speak进栈执行,调用者是p对象,this就是p对象本身,因此p将对象地址传递给this,于是this也指向这一片内存空间
于是我们发现,刚才的Person类这样写会更规范:
public class Person {
private String name;
private int age;
public void setAge(int a) {
if (a < 0 || a > 100) {
this.age = 20;
} else {
this.age = a;
}
}
public void setName(String n) {
this.name = n;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void speak() {
String name = "李四";
int age = 16;
System.out.println(this.age + "岁的" + this.name + "在说话");
}
}继承:
类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类
子类会自动拥有父类所有可继承的属性和方法
举例:
public class Employee {
String name;
public void work(){
System.out.println("员工"+name+"在工作");
}
}public class Develop extends Employee{
public void print(){
System.out.println(name);
}
}public class Test {
public static void main(String[] args) {
Develop d = new Develop();
d.name = "张三";
d.print();
d.work();
}
}
继承的特点和优点在这个例子中都体现出了
1.提高代码的复用性,提升开发效率
2.继承的出现让类与类之间产生了关系,提供了多态的前提
注意事项:
java只支持单继承,不支持多继承,因为有安全隐患,例如两个父类有重名方法时
可以使用连续继承(多重继承)实现多继承,这种方式合法
成员变量的变化:
子类定义的变量如果和父类重名,调用子类的时候,以子类的变量为准,如果子类不存在这个变量,则去父类中寻找,但是有一个super关键词可以指定在父类中寻找
public class Fu {
int i = 1;
}public class Zi extends Fu {
int i = 2;
public void show(){
System.out.println(super.i);
}
}public class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}这时候的输出结果为1,关于super的知识在后面详写
子类重写父类方法:
子类中,出现了和父类一样的方法的时候,称为子类重写父类的方法
用super.调用父类的功能,再写入新的功能
注意:子类如果要覆盖父类方法,必须要保证权限大于或等于父类权限(public>protected>default>private)
抽象类:
只有声明,没有定义
抽象方法必须存在于抽象类中
抽象类,不能实例化对象(不能使用new)因为抽象类没有主体,无法运行
抽象类的使用:必须定义类继承它,将抽象方法重写,创建它的子类的对象,并且强制让子类重写方法
public abstract class Person {
public abstract void work();
}public class Teacher extends Person {
public void work() {
System.out.println("老师在工作");
}
}public class Engineer extends Person {
public void work() {
System.out.println("工程师在工作");
}
}public class Test {
public static void main(String[] args) {
Teacher t = new Teacher();
Engineer e = new Engineer();
t.work();
e.work();
}
}输出:
老师在工作
工程师在工作
抽象类主要是为了学习它的设计思想:
抽象类的作用:继承的体系
抽象类强制子类重写抽象方法,保证体系功能的完整性
抽象类的一些注意事项:
1.有抽象方法的一定是抽象类,抽象类不止有抽象方法
2.抽象关键字abstract不可以共存的:private,final,static
3.抽象类必须是父类