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@1eb44e46package 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运行结果：
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关系不能用继承