java零基础7--面向对象的编程(3)

• this关键字
• • 1.什么是this？
  • 2.this的内存图
  • 3.this什么时候不可以省略
  • 4.this()
• 继承
• • 1.什么是继承
  • 2.继承的语法
  • 3.方法覆盖
  • 4.方法覆盖时的返回值问题

this是一个关键字，代表当前对象，指向自身。

例子：

public class thistext
{
	public static void main (String[] args){
		customer c1 = new customer ("张三");
		customer c2 = new customer ("李四");
		c1.shopping();//this是c1
		c2.shopping();//this是c2
	}
}

class customer
{
	String name;
	public customer (){}
	public customer (String s){
		name = s;
	}

	public void shopping (){
		//这里的this是当前对象
		//c1调用shoppingthis就是c1，c2同理
		//这里的name应该是this.name，当c1调用时，就是c1，c2调用时就是c2，这里的this可以省略
		System.out.println(name+"正在购物");
	}
}

（下图来源于动力节点杜老师的课程）
下图可以直观地说明this所保存的是当前对象的地址

this在大多数情况下可以省略的，this不能省略时的作用就是区分局部变量和实例变量

class student
{
	private int no;
	private String name;
	public student (){}
	public student (int i,String s){
		no = i;
		name = s;
	}

	//这里用到了封装，这样写可以增强代码可读性
	public void setNo(int no ){
		//no = no ;根据就近原则，这两个no都是局部变量no，和实例变量没欢喜
		//修改
		this.no = no;//这个this.的作用是区分局部变量和实例变量
	}
	public int getNo(){
		return no;
	}
	public void setName(String name){
		this.name = name;//这里同理，若不加this会报错
	}
	public String getName(){
		return name;
	}
}

this():通过当前的构造方法，去调用本类的另一个构造方法，实现了代码的复用
注意：
1.this()只能出现在构造方法的第一行

例子：

class date
{
	private int year;
	private int month;
	private int day;
	//调用有参的构造方法，日期是固定的
	public date (){
		this (1977,1,1);

        //相当于实现了
        
	}

	//有参
	public date (int year , int month , int day){
		this.year = year;
		this.month = month;
		this.day = day;
	}

继承可以达到代码复用的效果，定义一个子类，去继承父类，该子类有父类所有的属性和方法并且可以对其作出修改。

实现继承的关键字：extends
例子：

//父类
class account
{
	private String name;
	private double balance;
	public void setName (String name){
		this.name = name;
	}
	public String getName (){
		return name;
	}
	public void setBalance (double balance){
		this.balance = balance;
	}
	public double getBalance (){
		return balance; 
	}
}

//子类
class creditAccount extends account
{
	private double credit;
	public void setCredit(double credit){
		this.credit = credit;
	}
	public double getCredit (){
		return credit;
	}
}

父类中的代码子类中也会有，使用继承，大大增强了代码的复用性。

案例：

子类继承父类后，可以通过方法重载机制，对继承过来的需要修改的方法进行覆盖

class animal
{
	public void move (){
		System.out.println("动物在移动");
	}

	public void sing (int i){
		System.out.println("animal sing");
	}
}

class brid extends animal
{
	//子类继承父类之后，有一些行为可能需要改进
	//对move方法进行重写，最好将父类中的代码复制过来在重写，这样可以防止出错
	//方法覆盖，就是把继承来的方法覆盖掉了，这里覆盖了move方法
	public void move (){
		System.out.println("鸟儿在飞翔");
	}

	//此处构成了方法重载而不是方法覆盖，因为参数不同
	public void sing (){
		System.out.println("brid sing");
	}
}

class cat extends animal 
{
	public void move (){
		System.out.println("猫在走猫步");
	}
}

class animal
{
	public double sum (int a,int b){
		return a+b;
	}
}
//报错，无法覆盖
//对于返回值类型是基本数据类型，必须一致
//对于返回值类似是引用数据类型，返回值可以向下转型但不能向上转型
class cat extends animal
{
	public int sum (int a,int b){
		return a+b;
	}
}