DAY01 面向对象回顾、继承、抽象类

学习目标

能够写出类的继承格式public class 子类 extends 父类{}public class Cat extends Animal{}
能够说出继承的特点子类继承父类,就会自动拥有父类非私有的成员
能够说出子类调用父类的成员特点1.子类有使用子类自己的2.子类没有使用,继承自父类的3.子类父类都没有编译报错
能够说出方法重写的概念发生在两个类之间子类出现了和父类一模一样(返回值类型,方法名,参数列表,修饰符子类大于等于父类)的方法,叫方法重写(Override)
能够说出this可以解决的问题1.this.变量名:代表本类的成员变量2.this.方法名称():代表本类的成员方法3.this(),this(参数):代表调用本类其他的构造方法
能够说出super可以解决的问题1.super.变量名:代表父类的成员变量2.super.方法名称():代表父类的成员方法3.super(),super(参数):代表调用父类的构造方法
描述抽象方法的概念没有方法体,被abstract修饰的方法
写出抽象类的格式public abstract class 类名{};
写出抽象方法的格式权限修饰符 abstract 返回值类型 方法名(参数);public abstract void aaa();public abstract int bbb();public abstract int ccc(String s);
能够说出父类抽象方法的存在意义在抽象类中定义类抽象方法,那么子类就必须重写这个抽象方法公司中所有的员工都必须工作作为模版:让子类强制重写抽象方法,不同的子类添加不同的方法体

一.面向对象回顾

1.面向对象的概念

package com.itheima.demo01Object;/*面向对象:学习的重点记住概念,根据概念写出代码面向对象:基于面向过程面向过程:当我们遇到一件事情的时候,我们自己分析事情的解决步骤,按照步骤一步一步完成,重视的是解决事情的过程面向对象:当我们遇到一件事情的时候,我们不自己完成,找一个能够帮我们完成事情的对象,调用对象的功能完成.重视的是对象现实生活中的事物:属性,行为(功能)我们可以把现实生活中的事物抽象为java中的类(类是java的基本单位)把事物的属性抽象为类中的成员变量(定义在成员位置的变量:类中,方法外)把事物的行为抽象为类中的成员方法(定义在成员位置的方法,去掉static关键字)封装:私有成员变量,对外提供公共的get/set方法构造方法:创建对象就是调用类中的构造方法定义格式:修饰符 构造方法名-类名(参数){为成员变量赋值}特点:1.没有返回值类型,不是void,是根本就没有2.没有返回值3.必须和类名相同构造方法的注意事项:1.类中没有定义构造方法,JVM会为类添加一个 默认的空参数的构造方法格式: public Student(){ }2.类中已经定义了构造方法(空参,带参),那么JVM就不会给类添加默认的构造方法了所以我们要使用空参数的构造方法,必须自己手动写出3.构造方法是可以重载(在一个类中方法名称相同,但是参数列表不同(个数,顺序,数据类型)的方法)*/
public class Student {//私有成员变量private String name;private int age;public Student() {System.out.println("Student类的空参数构造方法!");}public Student(String name, int age) {this.name = name;this.age = age;System.out.println("Student类的满参数构造方法!");}//对外提供公共的get/set方法public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.itheima.demo01Object;/*测试类:包含main方法的类*/
public class Demo01Student {public static void main(String[] args) {//使用Student类的空参数构造方法创建对象Student s1 = new Student();//使用set方法给成员变量赋值s1.setName("迪丽热巴");s1.setAge(18);//使用get方法,获取成员变量的值System.out.println(s1.getName()+"\t"+s1.getAge());//使用Student类的满参数构造方法创建对象Student s2 = new Student("古力娜扎",18);//使用set方法,修改成员变量的值s2.setAge(20);//使用get方法,获取成员变量的值System.out.println(s2.getName()+"\t"+s2.getAge());}
}

2.this关键字

package com.itheima.demo02this;/*this关键字:代表本类对象的引用==>根据类创建的对象哪个对象调用的方法,方法中的this就是哪个对象this关键字作用:当局部变量和成员变量重名时,使用this关键字可以区分局部变量和成员变量this.变量名==>成员变量*/
public class Person {private String name;//定义成员方法public void show(){System.out.println("this:"+this);//this:com.itheima.demo02this.Person@4554617cString name = "小强";System.out.println("name:"+name);//name:小强 变量的就近访问原则System.out.println("this.name:"+this.name);//this.name:旺财 this.变量名代表成员变量}public Person() {}public Person(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

package com.itheima.demo02this;public class Demo01This {public static void main(String[] args) {//创建Person对象Person p = new Person("旺财");System.out.println("p:"+p);//p:com.itheima.demo02this.Person@4554617cp.show();}
}

3.对象的内存图

4.匿名对象

package com.itheima.demo03Object;import java.util.ArrayList;/*匿名对象:创建对象时,只有创建对象的语句,没有把对象赋值给某个变量,这个对象叫匿名对象没有名字的对象特点:只能使用一次,使用完毕会被JVM在空闲的时候进行垃圾回收好处:可以节约内存,可以提高程序的效率作用:一般可以作为方法的参数和返回值使用*/
public class Demo01Animal {public static void main(String[] args) {//创建一个有名字的对象:可以重复使用Animal a1 = new Animal("Tom");a1.eat();a1.eat();//创建一个匿名对象:只能使用一次new Animal("Jerry").eat();//如果想要在使用匿名对象,需要重新创建new Animal("熊大").eat();System.out.println("---------------------------");//调用show方法,创建Animal对象为变量a2赋值show(a1);//如果方法的参数传递的对象只使用一次,就可以使用匿名对象show(new Animal("熊二"));System.out.println("----------------------------");//调用getAnimal方法//Animal a4 = getAnimal();==> new Animal("光头强");Animal a4 = getAnimal();a4.eat();System.out.println("----------------------------");ArrayList<Animal> list = new ArrayList<>();list.add(a1);//对象只使用一次,就可以使用匿名对象list.add(new Animal("加菲猫"));}/*定义一个方法,方法的参数使用Animal类型Animal a2 = a1 = new Animal("Tom");Animal a2 = new Animal("熊二")*/public static void show(Animal a2){a2.eat();}/*定义一个方法,方法的返回值类型使用Animal方法的返回值类型是Animal,就必须在方法中创建一个Animal对象返回方法的返回值类型是int,就必须在方法中返回一个整数...*/public static Animal getAnimal(){//Animal a3 = new Animal("光头强");//return a3;//对象只使用一次,就可以使用匿名对象return new Animal("光头强");}
}

package com.itheima.demo03Object;public class Animal {private String name;public void eat(){System.out.println(name+"在吃饭!");}public Animal() {}public Animal(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

二.继承

1.继承的概念

子类继承父类，子类就会自动拥有父类非私有的成员变量和成员方法

2.继承的定义格式

package com.itheima.demo04extends;/*定义父类员工类属性:姓名,年龄方法:工作*/
public class Employee {//属性:姓名,年龄String name;int age;//方法:工作public void work(){System.out.println(name+"在呕心沥血的工作!");}
}

package com.itheima.demo04extends;/*定义讲师类:讲师是公司员工的一种,所以可以继承员工类什么时候使用继承:我是你的一种的使用(is...a)继承的格式:public class 子类 extends 父类{ }子类:Teacher父类:Employee继承的特点:子类继承父类,子类就会自动拥有父类非私有的成员变量和成员方法在子类中可以定义子类特有的成员*/
public class Teacher extends Employee{//定义子类特有的打印姓名和年龄的方法public void print(){System.out.println(name+"\t"+age);}
}

package com.itheima.demo04extends;/*定义班主任类:班主任是公司员工的一种,所以可以继承员工类*/
public class BanZhuRen extends Employee {}

package com.itheima.demo04extends;/*测试继承:测试子类继承父类之后,是否会自动拥有父类非私有的成员继承的好处:1.可以提高代码的复用性(重复使用)2.继承使类与类之间产生了关系,是多态的前提*/
public class Demo01Extends {public static void main(String[] args) {//创建子类Teacher对象Teacher t = new Teacher();//使用子类继承自父类的成员变量t.name = "老白";t.age = 18;//使用子类继承自父类的成员方法t.work();//使用子类特有的成员t.print();//定义子类BanZhuRen对象BanZhuRen bzr = new BanZhuRen();//使用子类继承自父类的成员变量bzr.name = "美女";bzr.age = 18;//使用子类继承自父类的成员方法bzr.work();}
}

3.继承的注意事项

package com.itheima.demo05extends;public class Fu {private String name;private int age;//定义一个私有的成员方法private void siFangQian(){System.out.println("父亲老王的私房钱!");}public Fu() {}public Fu(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.itheima.demo05extends;public class Zi extends Fu {
}

package com.itheima.demo05extends;/*继承的注意事项:1.构造方法是不能继承的,构造方法是本类创建对象使用的2.父类私有成员子类是不能继承的*/
public class Demo01 {public static void main(String[] args) {Zi zi = new Zi();//私有的成员变量子类是不能继承使用//System.out.println(zi.name);//'name' has private access in 'com.itheima.demo05extends.Fu'//子类可以使用继承自父类公共的get/set方法,通过方法来操作变量zi.setName("小王");zi.setAge(10);//私有的成员方法子类是不能继承使用//zi.siFangQian();//'siFangQian()' has private access in 'com.itheima.demo05extends.Fu'}
}

4.继承后的特点—成员变量

package com.itheima.demo06Variable;public class Fu {int a = 10;
}

package com.itheima.demo06Variable;public class Zi1 extends Fu{int b = 20;
}

package com.itheima.demo06Variable;public class Zi2 extends Fu{int a = 100;int b = 200;
}

package com.itheima.demo06Variable;/*继承后的特点—成员变量1.子类有使用子类自己的成员变量2.子类没有使用子类继承自父类的成员变量3.子类和父类都没有,编译报错*/
public class Demo01Variable {public static void main(String[] args) {//创建子类对象Zi1 zi1 = new Zi1();System.out.println(zi1.a);//10 子类继承父类的System.out.println(zi1.b);//20 使用子类自己的//创建子类对象Zi2 zi2 = new Zi2();System.out.println(zi2.a);//100 使用子类自己的System.out.println(zi2.b);//200 使用子类自己的//System.out.println(zi2.c);//Cannot resolve symbol 'c' 子类和父类都没有,编译报错}
}

5.继承后的特点—成员方法

package com.itheima.demo07Method;public class Fu {public void show01(){System.out.println("Fu类的show01方法!");}
}

package com.itheima.demo07Method;public class Zi1 extends Fu{public void show02(){System.out.println("Zi1类的show02方法!");}
}

package com.itheima.demo07Method;public class Zi2 extends Fu{public void show01(){System.out.println("Zi2类的show01方法!");}public void show02(){System.out.println("Zi2类的show02方法!");}
}

package com.itheima.demo07Method;/*继承后的特点—成员方法1.子类有使用子类自己的成员方法2.子类没有使用子类继承自父类的成员方法3.子类和父类都没有,编译报错*/
public class Demo01Method {public static void main(String[] args) {//创建子类对象Zi1 zi1 = new Zi1();//使用子类继承自父类的成员方法show01zi1.show01();//使用子类自己的成员方法show02zi1.show02();//创建子类对象Zi2 zi2 = new Zi2();//使用子类自己的成员方法show01,show02zi2.show01();zi2.show02();//zi2.show03();//Cannot resolve method 'show03()'  子类和父类都没有,编译报错}
}

6.方法重写(Override)

package com.itheima.demo08Override;public class Fu {public void show01(){System.out.println("Fu类的show01方法!");}
}

package com.itheima.demo08Override;/*方法重写:发生在两个类之间,在子类中出现了和父类一模一样的方法,叫方法重写(Override)一模一样:方法名一样参数列表一样返回值类型一样修饰符一样(子类的修饰符权限大于等于父类的修饰符)注解:@Override:检查方法是否为重写的方法------------------------------------------------------------方法重载:发生在一个类中,在一个类中出现了方法名相同,但是参数列表不同的方法,叫方法重载(Overload)*/
public class Zi extends Fu{@Overridepublic void show01(){System.out.println("Zi类重写父类的show01方法!");}public void show01(int a){System.out.println("Zi类特有的show01方法!"+a);}//@Override//Method does not override method from its superclasspublic void show02(){System.out.println("Zi类的show02方法!");}
}

package com.itheima.demo08Override;public class Demo01Override {public static void main(String[] args) {//创建子类对象Zi zi = new Zi();zi.show01();//调用的是子类重写父类的show01方法}
}

7.方法重写的注意事项(了解)

package com.itheima.demo09Override;public class Fu {public void show01(){System.out.println("Fu类的show01方法");}void show02(){System.out.println("Fu类的show02方法");}public void show03(){System.out.println("Fu类的show03方法");}public void show04(){System.out.println("Fu类的show04方法");}private void show05(){System.out.println("Fu类的show05方法");}
}

package com.itheima.demo09Override;/*方法重写的注意事项:1. 方法重写是发生在子父类之间的关系。2. 子类方法重写父类方法，必须要保证权限大于等于父类权限。java中四大权限修饰符public:公共的protected:受保护的:默认的,不写就是默认的private:私有的3. 子类方法重写父类方法，返回值类型、方法名和参数列表都要和父类方法一模一样4. 私有方法不能被重写(父类的私有方法子类是不能继承)*/
public class Zi extends Fu{//2. 子类方法重写父类方法，必须要保证权限大于等于父类权限。/*void show01(){System.out.println("Fu类的show01方法");}*/public void show02(){System.out.println("Fu类的show02方法");}//3. 子类方法重写父类方法，返回值类型、方法名和参数列表都要和父类方法一模一样//@Override//Method does not override method from its superclasspublic void show03(int a){System.out.println("Zi类的show03方法");}/*public int show04(){System.out.println("Fu类的show03方法");return 1;}*///@Override//Method does not override method from its superclasspublic void show08(){System.out.println("Fu类的show03方法");}//@Override//Method does not override method from its superclass//就相当于在子类中定义了一个自己特有的私有方法,恰好名字和父类方法一样private void show05(){System.out.println("Zi类的show05方法");}
}

8.继承后的特点—构造方法

package com.itheima.demo10Constructor;public class Fu {int a = 10;public Fu() {System.out.println("Fu类的空参数构造方法!"+a);}
}

package com.itheima.demo10Constructor;public class Zi extends Fu{//int a = 1;//int b = 2;/*继承后的特点—构造方法在子类构造方法的第一行,有一个默认的super();super();作用就是调用父类的空参数构造方法子类继承父类,子类想要使用继承自父类的成员,就必须把父类加载到内存中,调用父类的构造方法创建父类对象父类进入到内存中,子类才可以使用父类的成员*/public Zi() {super();System.out.println("Zi类的空参数构造方法!"+a);}
}

package com.itheima.demo10Constructor;public class Demo01Constructor {public static void main(String[] args) {//创建子类对象Zi zi = new Zi();}
}

9.子父类的内存图解

10.使用this关键字和super关键字访问成员

package com.itheima.demo11ThisAndSuper;public class Animal {String name = "猫科动物";public void eat(){System.out.println("动物在吃饭!");}
}

package com.itheima.demo11ThisAndSuper;/*this关键字:本类对象的引用(根据Cat创建的对象)this.成员变量:本类的成员变量this.成员方法(参数):本类的成员方法super关键字:父类对象的引用(根据Animal创建的对象)super.成员变量:父类的成员变量super.成员方法(参数):父类的成员方法*/
public class Cat extends Animal {String name = "加菲猫";public void eat(){System.out.println("加菲猫在吃饭!");}public void show(){System.out.println(name);//加菲猫 变量的就近访问原则System.out.println("this.name:"+this.name);//加菲猫System.out.println("super.name:"+super.name);//猫科动物eat();//加菲猫在吃饭!this.eat();//加菲猫在吃饭!super.eat();//动物在吃饭!}
}

package com.itheima.demo11ThisAndSuper;public class Demo01ThisAndSuper {public static void main(String[] args) {//创建子类Cat对象Cat cat = new Cat();cat.show();}
}

11.this关键字:调用本类其他的构造方法

package com.itheima.demo12this;/*this关键字:可以调用本类其他的构造方法格式:this();调用空参数构造方法this(参数);调用带参数构造方法注意:1.this();|this(参数);调用构造方法必须写在构造方法中的第一行,创建对象必须优先执行2.构造方法不能相互调用(不能你调用我,我在调用你-->死循环)*/
public class Animal {private String name;private int age;public Animal() {//this("tom",10);//调用带参数构造方法System.out.println("Animal类的空参数构造方法!");}public Animal(String name, int age) {this();//调用空参数构造方法this.name = name;this.age = age;System.out.println("Animal类的带参数构造方法!");}public String getName() {//this();//Call to 'this()' must be first statement in constructor bodyreturn name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.itheima.demo12this;public class Demo01This {public static void main(String[] args) {//使用空参数构造方法创建Animal对象Animal a1 = new Animal();System.out.println(a1.getName()+"\t"+a1.getAge());/*执行结果:Animal类的带参数构造方法!Animal类的空参数构造方法!tom	10*///使用带参数的构造方法创建Animal对象Animal a2 = new Animal("jerry",5);System.out.println(a2.getName()+"\t"+a2.getAge());/*执行结果:Animal类的空参数构造方法!Animal类的带参数构造方法!jerry	5*/}
}

12.super关键字:调用父类的构造方法

package com.itheima.demo13super;public class Fu {public Fu() {System.out.println("Fu类的空参数构造方法!");}public Fu(int a) {System.out.println("Fu类的带参数构造方法!"+a);}
}

package com.itheima.demo13super;/*super关键字:调用父类的构造方法格式:super();调用父类的空参数构造方法super(参数);调用父类带参数构造方法注意:1.在子类的构造方法中没有写super();有一个默认的super();用于调用父类的空参数构造方法2.super();|super(参数);必须写在子类构造方法有效代码的第一行,构造方法必须优先执行3.在子类的构造方法中this和super不能同时出现,都必须写在有效代码第一行*/
public class Zi extends Fu {public Zi() {super();//调用父类的空参数构造方法,不写默认System.out.println("Zi类的空参数构造方法!");}public Zi(int a){super(a);//调用父类的带参数构造方法System.out.println("Zi类的带参数构造方法"+a);}
}

package com.itheima.demo13super;public class Demo01Super {public static void main(String[] args) {//使用Zi类空参数构造方法创建对象Zi zi = new Zi();//使用Zi类带参数构造方法创建对象Zi zi2 = new Zi(100);}
}

13.继承的特点

三.抽象类

1.抽象类&抽象方法概述

2.抽象类&抽象方法使用

package com.itheima.demo14abstractClass;/*定义父类员工类:是根据子类共性抽取形成定义成员变量:姓名,年龄定义成员方法:工作的方法每个子类方法的方法体不同,但是方法的声明相同(public void work())只抽取方法的声明,不抽取方法体抽取出来的方法声明添加一个关键字abstract,这个方法叫抽象方法定义格式:修饰符 abstract 返回值类型 方法名(参数);public abstract void work();public abstract void work(String a);public abstract int work(String a);包含抽象方法的类,也必须被abstract修饰,叫抽象类定义格式:public abstract class 类名{}----------------------------------------------------------注意:1.抽象类是无法直接创建对象使用的a.有一些类就是为了不让别人创建对象使用,可以定义为抽象类b.抽象类中一般都包含抽象方法,抽象方法没有方法体,创建对象调用抽象方法没有意义2.需要创建子类继续抽象父类,重写抽象类中的抽象方法,创建子类对象使用------------------------------------------------------------------------好处:在抽象类中定义抽象方法,那么子类就必须重写这个抽象方法公司中所有的员工都必须工作==>定义了一个模版==>子类都必须根据模版重写抽象方法*/
public abstract class Employee {private String name;private int age;//定义抽象的工作方法public abstract void work();public Employee() {}public Employee(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.itheima.demo14abstractClass;/*讲师类是一个员工类的一种,所以可以继承员工类讲师类已经能明确自己的工作内容了所以需要重写工作的方法,添加方法体注意:子类继承抽象类有两种处理方式 alt+回车1.子类也声明为抽象类(子类包含继承自父类的抽象方法)2.子类重写抽象方法,添加方法体*/
public class Teacher extends Employee{@Overridepublic void work() {System.out.println("正在给大家讲解java!");}
}

package com.itheima.demo14abstractClass;/*班主任类是一个员工类的一种,所以可以继承员工类班主任类已经能明确自己的工作内容了所以需要重写工作的方法,添加方法体*/
public class BanZhuRen extends Employee{@Overridepublic void work() {System.out.println("正在监督大家学习!");}
}

package com.itheima.demo14abstractClass;//抽象类是无法创建对象使用的
public abstract class JiuYeZhiDao extends Employee{
}

package com.itheima.demo14abstractClass;public class Demo01AbstractClass {public static void main(String[] args) {//Employee ee = new Employee();//'Employee' is abstract; cannot be instantiated 抽象类是无法直接创建对象使用的//创建子类对象Teacher t = new Teacher();t.work();BanZhuRen bzr = new BanZhuRen();bzr.work();//JiuYeZhiDao jyzd = new JiuYeZhiDao();//'JiuYeZhiDao' is abstract; cannot be instantiated}
}

3.模版设计模式

package com.itheima.demo15driver;/*定义开车类的模版:在父类中调用子类重写后的方法定义一些固定的内容(开门,点火,刹车,熄火)不同的内容定义为抽象方法(开车姿势不同)*/
public abstract class Driver {//定义开车的方法public void driver(){System.out.println("开门..............");System.out.println("点火..............");ziShi();System.out.println("刹车..............");System.out.println("熄火..............");}//新司机和老司机开车的姿势不同,定义为抽象方法public abstract void ziShi();
}

package com.itheima.demo15driver;//定义新司机类,是司机类的一种,所以继承司机类
public class NewDriver extends Driver{@Overridepublic void ziShi() {System.out.println("新司机开车的姿势:双手紧握方向盘!");}
}

package com.itheima.demo15driver;//定义老司机类,是司机类的一种,所以继承司机类
public class OldDriver extends Driver{@Overridepublic void ziShi() {System.out.println("老司机开车姿势:右手握方向盘左手抽烟");}
}

package com.itheima.demo15driver;public class Demo01Driver {public static void main(String[] args) {//创建新司机对象NewDriver nd = new NewDriver();nd.driver();//创建老司机对象OldDriver od = new OldDriver();od.driver();}
}