Extends 继承

extends 关键字：用于指定某个指定的父类

package com.zttdemo01Window;

import javax.swing.JFrame;
//extends 关键字：用于指定某个指定的父类

//子类：Window
//父类：JFrame
public class Window extends JFrame{
	
	//构造代码块
	{
		//设置窗体关闭时，应用程序退出exit
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
		//设置窗体标题文字
		this.setTitle("beat适用版本");
	}
	
	//无参构造方法
	public Window() {
		//设置窗体尺寸大小
		this.setSize(500,350);
		
	}
	
	//有参构造方法
	public Window(int width,int height) {
		this.setSize(width,height);
	}
}

测试类：

package com.zttdemo01Window;

public class test1 {

	public static void main(String[] args) {
		// 创建窗体对象
		Window w1=new Window();
		Window w2=new Window(200,100);
		Window w3=new Window(200,100);
		//设置窗体可见
		w1.setVisible(true);
		w2.setVisible(true);
		w3.setVisible(true);
	}

}

package com.zttdemo02Product;
//商品类
//父类
public class Product {
	
	// private修 饰的成员变量(方法)，子类无法继承(无法访问)
	private double price;//价格
	private int stock;//库存
	
	//无参构造方法
	public Product() {
		
	}
	
	//有参构造方法
	public Product(double price,int stock) {
		this.price = price;
		this.stock = stock;		
	}
	
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		if(price<=0) {
			this.price = 0.01;
		}else {
			this.price = price;
		}		
	}
	public int getStock() {
		return stock;
	}
	public void setStock(int stock) {
		this.stock = stock;
	}	
}

//图书类
//子类
class Books extends Product {
	private String bookName;//图书名称
	private String author;//作者姓名
	
	public Books(String bookName,String author,double price,int stock) {
		//直接保存至“图书类”的成员变量中
		this.bookName = bookName;
		this.author = author;
		
		//通过父类的set方法，将价格和库存，保存至父类的成员变量
//		this.setPrice(price);
//		this.setStock(stock);
		
		
		super.setPrice(price);
		super.setStock(stock);
	}
	
	@Override
	public String toString() {
		String s = String.format("图书名称：《%s》,￥%f,作者：%s,库存：%d", 
				this.bookName,super.getPrice(),this.author,super.getStock());
		return s;
	}

}

//手机类
//子类
class Phone extends Product {
	private String model;
	private int memory;
	
	public Phone(String model,int memory,double price,int stock) {
		
//		super.setPrice(price);
//		super.setStock(stock);
		

		super(price,stock);
		
		this.model = model;
		this.memory = memory;
		
		
	}
	@Override
	public String toString() {
		String s = String.format("手机商品：【%s】,￥%f,内存%dG,库存%d部", this.model,super.getPrice(),this.memory,super.getStock());
		return s;
	}
	
	
}

//食品类
class Food extends Product{
	
}

?

测试类：

package com.zttdemo02Product;

public class test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Book book1 = new Book("皮皮鲁和鲁西西","郑渊洁",5,100);
		System.out.println(book1);
		
		Phone phone=new Phone("phone15",1024,9999,25);
		System.out.println(phone);
	}
}

运行结果：

图书名称：《皮皮鲁和鲁西西》,￥5.000000,作者：【郑渊洁】,库存：100
手机商品：【phone15】,￥9999.000000,内存1024G,库存25部

?

package com.zttdemo03Father;
//准则1：在继承关系中，子类的构造方法必须要"能调用到父类的构造方法"
//准则2：创建子类对象时，先调用父类构造方法，再执行子类构造方法

//父类

public class Father {
	//构造代码块
	{
	System.out.println("Father父类的构造代码块3");	
	}
	
	public Father(){
		System.out.println("Father父类的【无参】构造方法。。。");
	}
	
	{
		System.out.println("Father父类的构造代码块2");	
		}
	
	//有参构造方法
	public Father(int x){
		System.out.println("Father父类的【有参】构造方法。。。");
	}
	
	{
		System.out.println("Father父类的构造代码块1");	
		}

}

//子类

class Son extends Father{
	//构造代码块
	{
		System.out.println("Son子类的构造代码块1");
	}
	
	//在子类的构造方法中，手动的调用父类的构造方法
	public Son() {
		//手动的调用父类的构造方法
		super(1);
		
		//当父类中，存在无参构造方法时，子类会自动调用父类的无参构造l 
		//super(); //不需要手动调用
		
		System.out.println("Son子类的【无参】构造方法。。。");
	}
	
	{
		System.out.println("Son子类的构造代码块2");
	}
	
	public Son(int a) {
		//手动的调用父类的构造方法
		//super(1);
		
		//当父类中，存在无参构造方法时，子类会自动调用父类的无参构造l 
		//super(); //不需要手动调用
		
		System.out.println("Son子类的【有参】构造方法。。。");
	}
	
	{
		System.out.println("Son子类的构造代码块3");
	}
	
}

测试类：

package com.zttdemo03Father;

public class test {

	public static void main(String[] args) {
		// 子类的无参构造方法
		Son s=new Son();
		
		// 子类的有参构造方法
//		Son s=new Son(1234);
	}

}

运行结果：

Father父类的构造代码块3
Father父类的构造代码块2
Father父类的构造代码块1
Father父类的【有参】构造方法。。。
Son子类的构造代码块1
Son子类的构造代码块2
Son子类的构造代码块3
Son子类的【无参】构造方法。。。

package com.zttdemo04Person;

//public : 公共，任意位置均能访问
//protected :受保护，仅限子类访问
//private :私有，仅限当前类
public class Person {
   protected String name;//允许子类直接访问
   private int age;

}
class Student extends Person {
   public String hello() {
	
//子类允许访问父类protected修饰的成员变量或方法return "Hello," + name;
	   return "Hello,"+name;
   }
}

测试类;

package com.zttdemo04Person;

public class test {

	public static void main(String[] args) {
		//向上转型：允许父类的引用指向一个子类的对象
		Person p1=new Student();
		Person p2=new Person();
		
		//向下转型︰将父类的引用指向的对象，强制转换为具体的子类对象
		Student s1 = (Student)p1;
		System.out.println( "s1=" + s1);
//		Student s2 = (Student)p2;
//		System.out.println( "s2=" + s2);
		
	}

}

运行结果：

s1=com.zttdemo04Person.Student@1eb44e46

package com.zttdemo05Computer;
//父类
public class Computer {
	private String cpu;//中央处理器
	private int ssd;//固态硬盘
	
	//无参构造方法
	public Computer() {
		
	}
	
	//有参构造方法
	public Computer(String cpu,int ssd) {
		this.setCpu(cpu);
		this.setSsd(ssd);
	}

	public String getCpu() {
		return cpu;
	}

	public void setCpu(String cpu) {
		this.cpu = cpu;
	}

	public int getSsd() {
		return ssd;
	}

	public void setSsd(int ssd) {
		this.ssd = ssd;
	}
}
	
	//子类：PC台式机
	class PersonComputer extends Computer{
		private String displayCard;//显卡
		
		public PersonComputer(String cpu,int ssd,String displayCard) {
			//手动调用父类的有参构造方法
			super(cpu,ssd);
			
			//保存
			this.setDisplayCard(displayCard);
		}

		public String getDisplayCard() {
			return displayCard;
		}

		public void setDisplayCard(String displayCard) {
			this.displayCard = displayCard;
		}
	}
		
		//子类：笔记本
		class NotebookComputer extends Computer{
			private String brand;//品牌
			
			public NotebookComputer(String cpu,int ssd,String brand) {
				super(cpu,ssd);
				this.setBrand(brand);
			}

			public String getBrand() {
				return brand;
			}

			public void setBrand(String brand) {
				this.brand = brand;
			}
			
		}
		
	
	

测试类：

package com.zttdemo05Computer;


public class test {
	public static void main(String[] args) {
		//对象数组
		//类型如果是父类，代表数组内可以保存任意一种子类的对象
		Computer[] array= {
				new PersonComputer( "Intel i9",128, "8090Ti"),
				new NotebookComputer( "AMD R9",512,"华硕"),
				new NotebookComputer( "AMD R9" ,512,"小米"),
				new PersonComputer( "Intel i9",128, "4090Tiplus+++")
				
		};
		
		for(int i=0;i<array.length;i++) {
			//获取数组中的一个元素
			Computer comp=array[i];
			System.out.println(comp);
			
			//向下转型
			//instanceof运算符：判断当前引用comp指向的对象类型是PersonComputer
			if(comp instanceof PersonComputer) {
				//如果是PC台式机，输出显卡型号
				PersonComputer pc=(PersonComputer)comp;
				System.out.println("台式机的显卡型号："+pc.getDisplayCard());
			}else if(comp instanceof NotebookComputer) {
				NotebookComputer nb=(NotebookComputer)comp;
				System.out.println("笔记本电脑的显卡型号："+nb.getBrand());
			}
		}
	}
}

运行结果：

com.zttdemo05Computer.PersonComputer@6504e3b2
台式机的显卡型号：8090Ti
com.zttdemo05Computer.NotebookComputer@379619aa
笔记本电脑的显卡型号：华硕
com.zttdemo05Computer.NotebookComputer@cac736f
笔记本电脑的显卡型号：小米
com.zttdemo05Computer.PersonComputer@5e265ba4
台式机的显卡型号：4090Tiplus+++

总结：?

继承是面向对象编程的一种强大的代码复用方式. Java只允许单继承，所有类最终的根类是object
子类可以访问访问父类的public和protected字段和方法。子类的构造方法可以通过super()调用父类的构造方法
当父类中不存在无参构造方法时，子类必须手动的调用父类的有参构造方法，并且必须在子类构造方法中的第一行
可以安全地向上转型为更抽象的类型
向下转型，可以使用instanceof运算符:用于判断"引用指向的对象"是否是"指定类型"，运算结果为boolean类型
子类和父类的关系是is , has关系不能用继承?

?

?

?

?

?

?

?

?

?

?

?

?