Java三大特征之一——继承以及this关键字

1.this关键字

①一般写在实体类中，表示的是当前的对象；

②可以使用this调用属性和方法；

③this关键字可以调用构造方法（很少用）；

注意：（1）一定是在构造方法中调用另一个构造方法

           （2）在构造方法中调用其他构造方法的时候一定要写在首行

class Person {
	
	String name;
	int age;
	
	public Person () {
		System.out.println("Line 9：  "+ this);//代表是当前的对象
		this.name = "狗蛋";//this可以调用属性
	}
	
	public void  eat () {
		//this可以调用方法
		this.test();
	}
	public void test () {
		System.out.println("嘻嘻");
	}
	
}
public class Demo1 {
	public static void main(String[] args) {
		Person person1 = new Person();
		System.out.println(person1);//对象的内存地址  15db9742
		System.out.println(person1.name);
		person1.eat();
		
		Person person2 = new Person();
		System.out.println(person2);//对象的内存地址6d06d69c
		System.out.println(person2.name);
	}
}

2.方法的参数可以是一个类对象

方法的参数可以是八大基本数据类型、String、数组和类对象

例：人可以生孩子，孩子可以玩玩具，玩具被玩（在玩具类中打印玩具被玩）

class Adult {//成年人类
	
	public void birth (Child child) {
		Toy toy2 = new Toy();
		child.playToy(toy2);
	}
}
class Child {
	public void playToy (Toy toy) {
		toy.bePlay();
	}
}
class Toy {
	public void bePlay () {//玩具被玩
		System.out.println("被玩，很开心");
	}
}
public class Demo6 {
	public static void main(String[] args) {
		Adult adult = new Adult();
		Child child= new Child();
		adult.birth(child);
	}
}

3.多类合作

一个类对象可以作为另外一个类的属性

class RenLei {//人类
	
	String name;
	int age;
	BigDog bigDog;//bigDog这个对象带了三个数据   牛彩云    3   黑色
}
class BigDog {
	String name;
	int age;
	String color;
	
}
public class Demo8 {
	public static void main(String[] args) {
		
		BigDog bd = new BigDog();
		bd.name = "牛彩云";
		bd.age = 3;
		bd.color = "黑色";
		RenLei renLei = new RenLei();
		renLei.name = "二贝";
		renLei.age = 38;
		renLei.bigDog = bd;
		System.out.println(renLei.name);
		System.out.println(renLei.age);
		//人的狗 狗的名字
		System.out.println(renLei.bigDog);//内存地址
		System.out.println(renLei.bigDog.name);//  牛彩云
		System.out.println(renLei.bigDog.age);//3
		System.out.println(renLei.bigDog.color);//黑色
		
		
	}
}

4.继承

4.1语法格式：

class A{

        属性；

        方法；

}

class B extends A{

        B可以继承父类的属性和方法

}

入门案例：

class Father {
	//属性
	String name;
	int age;
	//行为
	public void eat () {
		System.out.println("吃窝窝头");
	}
	
}
class Son extends Father{//想让Son 去继承Father类
	
	
}
public class Demo9 {
	public static void main(String[] args) {
		Son son = new Son();
		son.name = "大头";//儿子类中可以使用父类的属性
		son.age = 15;
		System.out.println(son.name);
		System.out.println(son.age);
		son.eat();
	}
}

子类继承父类后可以使用父类的属性和方法

①成员变量（属性）

公开的和默认的属性子类可以使用，私有的属性子类无法使用

②成员方法

公开的和默认的方法子类可以使用，私有的方法子类无法使用

③构造方法

        （1）先执行父类的构造方法，然后再执行子类的构造方法

        （2）如果父类中没有无参构造方法，子类也不能有无参构造方法

        （3）子类构造方法必须调用父类的某个构造方法

class Father1 {
	//公开的和默认的属性可以被子类继承的
	public String name;//公开的属性
	int age;//默认的属性
	
	private int id;//私有化的
	
	public Father1 () {
		
	}
	
	public Father1(String name, int age, int id) {
		
		this.name = name;
		this.age = age;
		this.id = id;
	}
	//公开的方法
	public  void  eat () {
		System.out.println("吃红薯面");
	}
	//默认的方法
	void  work () {
		
		System.out.println("翻地球");
	}
	//私有话的方法  子类无法使用的e
	private void smoking () {
		System.out.println("抽旱烟");
	}
}
class Son1 extends Father1{

	public Son1 () {
		
	}
	public Son1(String name, int age, int id) {
		super(name, age, id);//调用父类的有参构造方法
		// TODO Auto-generated constructor stub
	}
	
	//mplicit super constructor Father1() is undefined. Must explicitly invoke another constructor
	//父类中不存在，儿子的无参构造方法也不能存在
//	public Son1 () {
//		System.out.println("这个是子类的无参构造方法");
//	}
	
	  //总结：   子类的构造方法必须依靠父类的构造方法的形似来进行创建
	
}
public class Demo10 {
	public static void main(String[] args) {
		Son1 son1 = new Son1();
		son1.name = "小灰灰";//发现确实可以继承
		son1.age = 17;//发现 默认的属性也是可以继承
		//the field Father1.id is not visible  不可见 
		//son1.id = 12;
		son1.eat();
		son1.work();
		//son1.smoking();
		
		
		
		
		
	}
}

4.2关于继承的概念

①B继承了A，B叫作A的子类，A是B的父类  超类  基类  祖宗类

②Java中是单继承（只能有一个父类）但是可以多重继承

③父类和子类的内存分析↓

4.3重写和重载 

4.3.1重写（override）

重写的目的：父类的方法需求无法满足子类的需求

重写的规则：

        ①必须有继承关系

        ②在子类中重写父类的方法

        ③父类的方法必须是公开的或默认的

        ④在子类中重写父类的方法除了方法体不太一样，其他都一样（方法的返回值， 方法的名字 ，方法的参数）

class Father3 {
	public void eat () {
		System.out.println("吃窝窝头");
	}
}
class Son3 extends Father3{
	/*
	 * //重写:  就是把父类的方法重新写一遍，就是内容不一样
	 * 父类的方法不能动，子类的方法重新写了一遍
	 * 除了方法体中的内容不一样，其他都是一样的
	 * 
	 * 其他是啥：
	 * 	1.方法的名字
	 * 	2.方法返回值
	 * 	3.方法的参数
	 */
//	public void eat (String name) {
//		System.out.println(name + "吃大盘鸡");
//	 }
	@Override  //重写的严格限定 告知程序员 下面方法是重写的方法，不是自己独有的方法
	public void eat() {
		System.out.println("吃烤鸭");
	}
	
}
public class Demo5 {
	public static void main(String[] args) {
		Son3 son3 = new Son3();
		son3.eat();//调用的父类的方法
		//son3.eat("狗蛋");//调用的是子类独有的方法
	}
}

4.3.2重载（overload）

在Java中的同一个类中，有很多的方法，如果方法的名字一样，参数列表不一样，那么方法之间叫重载

重载的规则：

        ①方法的重载必须写在同一个类中
        ②方法的名字的一样
        ③方法的参数列表一定不一样
        ④方法的返回值可以一样也可以不一样
        ⑤无参构造方法和有参构造方法也是方法的重载

import java.beans.IntrospectionException;

class Person {
	
	public void eat () {
		System.out.println("吃饭");
	}
	public void eat (String name) {
		System.out.println(name + "吃黄焖酥肉");
	}
	public void eat (String kind, int a) {
		System.out.println(kind + "吃 "+a+"份黄焖酥肉");
	}
	public int eat (int a) {
		return a;
	}
}

public class Demo7 {
	public static void main(String[] args) {
		
	}
}

4.4super关键字

this：代表当前对象

①this可以调用属性和方法

②this可以调用构造方法

super：代表父类的对象

①super可以调用属性和方法（不重要）

②super可以调用父类的构造方法

class Father {
	String name;
	int age;
	
	public Father (String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public void eat () {
		System.out.println("吃饭");
	}
}
class Son extends Father{
	
	
	//无参构造方法
	public Son () {
		//JVM  虚拟机会默认调用调用父类的无参构造方法
		//super();//在子类的无参构造方法中去掉用了父类的无参构造方法
		//在子类的无参的构造方法中 去默认调用 父类的无参的构造方法 现在没有  就报错
		//
		
		super("狗蛋", 12);//调用父类的有参的构造方法
		//在一个构造方法中  能同时调用两个父类的构造方法吗？ 不能的 就意味着  super()  这个默认的
		//无参构造方法就不再执行了
		
		//总之:  子类的构造方法 在调用父类的构造方法的时候，一定要确保  父类中有此对应好的构造方法
	}
	
	
	public void test () {
		super.name = "狗蛋";//调用父类的name变量    
		this.name = "二蛋";
		super.eat();//调用父类的eat方法
		
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		//son.eat();
		son.test();
	}
}

5.抽象类

如果一个类中没有足够的信息来描述一个对象，那么这个类叫抽象类

5.1抽象类声明

在Java中用abstract修饰的类叫抽象类

在Java中用abstract修饰的方法叫抽象方法

语法格式：

abstract class Person {
 
 //正常类的属性
 String name;
 //普通的成员方法
 public void eat () {
     System.out.print("吃饭");
 }
 //抽象方法   没有方法体的方法  没有大括号的
 public abstract void sleep ();
 
}

abstract class Person {//抽象类
	//抽象类中可以有属性  方法  抽象方法
	
	public  void eat () {//普通方法
		System.out.println("吃饭啊");
	}
	//声明一个抽象方法  abstract  修饰符
	//是一个不完整的方法，  完整方法应该带方法体
	 public abstract void  test (int a);
	
}

//The type Man must implement(实现) the inherited abstract method Person.test()
//在普通类中 Man中，必须可以实例化的。所以Man所有的信息都要时完整的
//必须去重写 父类中 抽象的方法
class Man extends Person{
	@Override
	public void test(int a) {//是重写的 抽象的类的抽象方法
		System.out.println( a + "这个是子类重写的的抽象父类的抽象的方法");
		
	}
}
public class Demo1 {
	public static void main(String[] args) {
		//抽象类不能创建对象 咋办？ 只能 被继承
//		Person person = new Person();
		Man man = new Man();
		man.eat();
		man.test();
	}
}

5.2抽象类详解

①如果一个类中有抽象方法，那么这个类一定是抽象类

②抽象方法是一个没有方法体的方法

③抽象类中可以有普通方法

④抽象类不能被实例化

⑤抽象类不能被实例化，但可以用普通类继承抽象类

⑥在子类中必须重写父类所有的抽象方法

⑦在抽象类中非抽象的方法可以在子类中被重写

⑧一个抽象类可以继承另外一个抽象类

⑨一个抽象类也可以继承一个非抽象类