day01 【复习回顾、继承、抽象类模板设计模式】
主要内容
1.面向对象回顾
2.封装(基础班),继承(今天),多态(明天+后天)
3.设计模式:模板设计模式
第一章 复习
1.1 如何定义类
格式:
public class 类名{
//成员变量
数据类型 成员变量名;
//成员方法
public 返回值类型 方法名(参数列表){
方法体;
return 返回值;
}
}
1.2 如何通过类创建对象
格式:
类名 对象名 = new 构造方法名(具体参数);
1.3 封装
-
封装的步骤
a.给成员变量加上private b.为每个成员变量,提供一组getter和setter -
封装的代码实现
public class Dog { //成员变量 private int age; private String name; //提供getter和setter //alt+insert 省略... //成员方法:吠 public void bark() { System.out.println("小狗嗷嗷叫~~~"); } } public class TestDog { public static void main(String[] args) { //创建对象 Dog dd = new Dog(); //封装之后,我们需要通过调用get和set方法来取值或者赋值 System.out.println(dd.getName()); System.out.println(dd.getAge()); //调用方法 dd.bark(); } }
1.4 构造器(构造方法)
-
构造器的作用
给创建出的对象的成员变量初始化!! -
构造器的格式
格式: public 类名(){ } public 类名(参数列表){ 给对象中成员变量赋值 } -
构造器的使用
无参构造: 类名 对象名 = new 构造方法名(); 有参构造: 类名 对象名 = new 构造方法名(实际参数); 例如: Dog dd = new Dog(); //使用无参构造 Dog dd2 = new Dog(10,"旺财");
1.5 this关键字
-
this关键字代表什么
代表当前对象的引用: 当前对象,成员方法由哪个对象调用的,方法中的this就代码那个对象 -
this在代码中的应用
a.在set方法中使用到this,给同名的成员变量赋值 public void setAge(int age) { this.age = age; } b.在构造方法中使用到this,给同名的成员变量赋值 public Dog(int age, String name) { this.age = age; this.name = name; }
1.6 匿名对象
-
什么是匿名对象
没有名字的对象!!!! 匿名对象是指只new对象,但是不用对象名来接收 正常对象: Dog d = new Dog(); 匿名对象: new Dog(); 注意: 这里匿名是指没有使用对象名接收,而不是对象中没有name属性 -
匿名对象的使用场景
当一个对象我们只需要使用一次时就可以选择使用匿名对象 public class NiMingDemo { public static void main(String[] args) { //需求:编写一个程序,要求用户输入他的年龄 System.out.println("请输入您的年龄:"); //使用正常对象 // Scanner sc = new Scanner(System.in); // int age = sc.nextInt();//ctrl+alt+v 或者 .var 自动接收方法返回值 //使用匿名对象 int age = new Scanner(System.in).nextInt(); System.out.println("您刚刚输入的年龄是:" + age); } }
第二章 继承
-
引入案例
假如我们要定义如下类: 学生类,老师类和班主任类，分析如下： 1. 学生类 属性:姓名,年龄 行为:吃饭,睡觉 2. 老师类 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书 3. 班主任 属性:姓名,年龄，薪水 行为:吃饭,睡觉，管理 如果我们定义三个类,每个类都有姓名,年龄,吃饭,睡觉
2.1 继承的概念
在一个已知类A的基础上,创建新类B的过程,称之为继承
这里类A,称为父类,基类,超类,英文名SuperClass
这里类B,称为子类,派生类,英文名SubClass
2.2 继承的格式
格式:
public class 父类{
//成员变量
//成员方法
}
public class 子类 extends 父类{
子类中就自动继承了父类中的成员变量和成员方法
子类也可以添加自己的成员变量和成员方法
}
2.3 继承的案例
父类:人类
public class Human {
//人类的共同成员变量和成员方法
int age;
String name;
public void eat(){
System.out.println("我吃蝙蝠...");
}
public void sleep(){
System.out.println("我听课睡着了...");
}
}
学生类:
public class Student extends Human{
}
老师类:
public class Teacher extends Human {
//薪水
double salary;
//教书
public void teach(){
System.out.println("#$%&*($%^*()%&*...");
}
}
班主任类:
public class BanZhuRen extends Human{
//薪水
double salary;
//管理
public void manager(){
System.out.println("开播了,赶紧起床~~~~");
}
}
测试类
public class TestDemo {
public static void main(String[] args) {
//1.测试Student类
Student s1 = new Student();
System.out.println(s1.age);
System.out.println(s1.name);
s1.eat();
s1.sleep();
//2.测试Teacher类
Teacher t1 = new Teacher();
System.out.println(t1.age);
System.out.println(t1.salary);
t1.eat();
t1.teach();
//3.班主任类...自己写完
}
}
-
继承好处总结
a.提高代码的复用性 b.类与类之间有了关系,为以后学的"多态"提供了前提
2.4 子类不能继承的内容
a.父类的构造方法子类无法继承!! (因为构造方法和类名是一样的)
b.父类的私有成员,子类可以继承但是不能直接使用!!!(间接使用)
父类:
public class Animal {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Animal() {
}
public Animal(int age) {
this.age = age;
}
}
子类:
public class Dog extends Animal {
//构造方法无法继承
//私有成员能继承,但是子类无法直接访问
}
测试类:
public class TestDog {
public static void main(String[] args) {
//1.创建Dog对象
Dog d = new Dog();
//2.构造方法无法继承
//Dog d1 = new Dog(10); //报错!!
//3.私有成员可以继承,但是无法直接访问
//d.age; //错误,无法直接访问
//比如:
//古代皇帝,皇帝驾崩了,太子继位,
//皇帝江山属于太子,但是皇帝妃子,太子也继承了叫额娘,但是不能用!!
//4.私有成员我们可以间接访问
//我们通过 get和set方法,间接访问私有成员
d.setAge(10);
int age = d.getAge();
System.out.println("获取到age:"+age);
}
}
2.5 继承后的特点——成员变量
a.当子父类的成员变量不同名时,访问成员变量时没有歧义,写哪个变量名就是访问哪个变量
b.当子父类的成员变量同名时,在子类中会根据就近原则,优先访问子类自己的那个成员变量
c.如果我就想访问父类的成员变量,能否做到???
可以,在子类的方法中,使用super.变量名,就会访问父类中那个成员变量!
/**
* 父类
*/
public class Fu {
// int numFu = 10;
int num = 10;
}
/**
* 子类
*/
public class Zi extends Fu{
// int numZi = 99;
int num = 99;
//展示
public void show() {
//子父类成员变量不同名
// System.out.println(numZi); // 99
// System.out.println(numFu); // 10
//子父类成员变量同名
//就近原则,优先访问子类自己的成员变量
System.out.println(num); // 99
//如果就想访问父类的num能否做到??
//使用Java提供的另外一个关键字
System.out.println(super.num); //10
}
}
public class TestDemo {
public static void main(String[] args) {
//1.创建Zi对象
Zi zz = new Zi();
//2.调用方法
zz.show();
}
}
2.6 继承后的特点——成员方法[重点]
a.当子父类的成员方法不同名时,调用成员方法时没有歧义,写哪个方法名就是调用哪个方法
b.当子父类的成员方法同名时,使用子类对象调用该方法,根据就近原则,优先调用子类自己的那个成员方法
c.如果我就想通过子类对象,调用父类中的那个同名方法,能做到吗???
不能做到!!
但是可以在子类的方法中,使用super.方法名()调用父类那个同名方法!!!
/**
* 父类
*/
public class Fu {
// public void showFu() {
// System.out.println("Fu类的show....");
// }
public void show() {
System.out.println("Fu类的show....");
}
}
/**
* 子类
*/
public class Zi extends Fu {
// public void showZi(){
// System.out.println("Zi类的show...");
// }
public void show(){
//在子类中可以使用super
System.out.println("Zi类的show...");
super.show();
}
}
public class TestDemo {
public static void main(String[] args) {
//1.创建子类对象
Zi zz = new Zi();
//2.调用方法
//子父类成员方法不同名
// zz.showZi(); //Zi类的show...
// zz.showFu(); // Fu类的show....
//子父类成员方法同名
//就近原则,优先子类自己的show方法
zz.show(); // Zi类的show...
//无法做到直接通过子类对象,super去调用父类的同名方法
//zz.super.show(); //报错!!!因为在测试类使用super,并不是Fu类,而是指测试类的父类
//可以在子类的show方法中,使用super.show()调用父类的同名方法
//记住: super关键字只能在子类内部使用
}
}
2.7 重写的概念和应用
方法的重载(overload):
在同一个类中,出现了方法名一样,但是参数列表(参数个数|参数类型|参数顺序)不一样的各种方法,称为方法的重载
方法的重写(override):
在继承关系中,子类中出现了一个和父类除了方法体,其他一模一样的方法,称为方法的重写
方法重写的具体应用:
子类继承父类时,会继承父类的成员方法,那么当子类发现继承过来的方法功能不足或者不适用时,子类就可以重写该方法,重新实现自己需要的方法体即可
/**
* 动物类
*/
public class Animal {
public void eat(){
System.out.println("动物在吃");
}
public void sleep(){
System.out.println("动物在睡");
}
}
/**
* 狗类
*/
public class Dog extends Animal{
//当子类继承父类的方法后,发现父类的方法功能不足或者不适用,我们可以重写
public void eat(){
System.out.println("狗狗舔着吃...");
}
public void sleep(){
System.out.println("狗狗趴着睡...");
}
}
2.8 @Override注解
@Xxxx 这种东西,我们称为注解,英文名Annotation
@Override 此注解叫做方法重写注解,
主要作用就是检查重写的方法是否格式正确(和父类的除了方法体一模一样)
/**
* 动物类
*/
public class Animal {
public void eat(){
System.out.println("动物在吃");
}
public void sleep(){
System.out.println("动物在睡");
}
}
/**
* 狗类
*/
public class Dog extends Animal{
//当子类继承父类的方法后,发现父类的方法功能不足或者不适用,我们可以重写
@Override //加上此注解,可以帮助我们检测eat方法重写的是否正确
public void eat(){
System.out.println("狗狗舔着吃...");
}
@Override //加上此注解,可以帮助我们检测eat方法重写的是否正确
public void sleep(){
System.out.println("狗狗趴着睡...");
}
}
2.9 方法重写的注意事项
a.方法重写是发生在子父类之间的关系
b.子类方法重写父类方法，必须要保证权限大于等于父类权限(一般来说,父类方法写啥权限,子类也写啥权限)
Java中有四大权限,从大到小依次为:
public protected 不写(默认|default) private
c.方法重写,除了方法体其他的都要和父类一模一样(虽然权限可以不一样,但是一般我们也写一样的权限)
2.10 继承后的特点——构造方法
-
构造方法特点介绍
a.子类能否继承父类的构造方法?? 子类是无法继承父类的构造方法 b.在子类的"任何构造方法"的"第一行",都有默认一句代码"super()",代表调用父类的无参构造 -
构造方法案例演示
/** * 父类 */ public class Person { int age; String name; public Person() { System.out.println("Person的无参构造..."); } } /** * 子类 */ public class Worker extends Person { //工资 double salary; //构造方法 public Worker(){ //默认有一句代码 super(); System.out.println("Worker的构造方法"); } public Worker(double salary){ //默认有一句代码 super(); this.salary = salary; System.out.println("Worker的salary构造方法"); } } public class TestDemo { public static void main(String[] args) { //1.创建Worker对象 // Worker w = new Worker(); // 调用子类无参构造,子类无参构造中调用父类的无参构造 Worker w = new Worker(3000); // 调用子类有参构造,子类有参构造中调用父类的无参构造 } } -
构造方法总结
a.子类的任何构造,第一行都会调用父类的无参构造 b.子类的构造方法第一行,super是默认存在的,可以省略不写,但是不写不代表没有!!!
2.11 super(参数)和this(参数)
-
案例引入
/** * 父类 */ public class Person { int age; String name; public Person() { System.out.println("Person的无参构造..."); } public Person(int age, String name) { this.age = age; this.name = name; System.out.println("Person有参构造"); } } /** * 子类 */ public class Worker extends Person { //工资 double salary; //构造方法 public Worker(){ //默认有一句代码 super(); System.out.println("Worker的构造方法"); } public Worker(double salary){ //默认有一句代码 super(); this.salary = salary; System.out.println("Worker的salary构造方法"); } //子类的构造中默认第一行调用父类无参构造 //但是我们可以手动修改super()代码,让他调用有参构造 public Worker(int age,String name,double salary){ //调用父类的有参构造 super(age,name); this.salary = salary; } } public class TestDemo { public static void main(String[] args) { //1.创建Worker对象 Worker w = new Worker(20,"小王吧",4000); //2.打印对象中属性值 System.out.println(w.name); System.out.println(w.age); System.out.println(w.salary); } } -
super(…)用法演示
super() 代表调用父类的无参构造,默认的 super(参数) 代表调用父类的有参构造,具体调用哪个有参构造根据参数来决定 -
super(…)案例图解
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f8iRHAMy-1583144789620)(img/image-20200302143555121.png)]
-
this(…)用法演示
this(参数): 在本类的构造方法中调用本类的其他构造 public class Dog { int age; String name; public Dog() { //在本类的构造方法中 this(10,"来福"); //调用本类的另外一个构造 } public Dog(int age, String name) { this.age = age; this.name = name; } } 注意: this(参数)也必须写在构造方法的第一行,所以this(参数)和super(参数)他们只能出现一个 -
小结
a.子类的构造方法中默认有一句super()调用父类无参构造,我们可以手动改写super(参数)调用父类的有参构造, 具体是哪个有参构造,由参数决定 b.super(...)和this(...) 必须在第一行,所有不能同时出现 c.super(..)和this(..)调用父类的构造和子类自己的其他构造,具体哪个构造由参数决定 d.super(..) 调用父类的有参构造,初始化父类继承的成员变量 e.this(..) 调用子类的其他构造方法
2.12 Java中继承的特点
1. Java只支持单继承，不支持多继承。(一个类最多只有一个亲爹)
2. 一个类可以有多个子类。(一个类可以有多个孩子)
3. 可以多层继承(一个类可以有父类,其父类也有父类)
总结: Java只支持单继承,但是支持多层继承
第三章 抽象类
3.1 抽象类的概念和引入
a.抽象方法: 只有方法的声明,没有方法的实现
b.含有抽象方法的类就是一个抽象类
3.2 abstract使用格式
-
抽象方法
public abstract 返回值类 方法名(参数列表); -
抽象类
public abstract class 类名{ 抽象方法 正常方法 } -
抽象类的使用
//抽象类:动物 public abstract class Animal { //抽象方法:跑 public abstract void run(); } 注意:抽象类是不能创建对象的,天生就是做父类的! 给其他子类继承的!!! 抽象类不能创建对象,需要有子类继承它,并且重写所有抽象方法之后,该子类才能创建对象 //抽象类:动物 public abstract class Animal { //抽象方法:跑 public abstract void run(); } /** * 抽象类的子类猫 */ public class Cat extends Animal { //a.给Cat也加上abstract //b.重写抽象类中所有的抽象方法 @Override public void run() { System.out.println("猫在屋顶上跑..."); } } public static void main(String[] args) { //1.创建Animal的对象 //Animal an = new Animal(); // Java规定抽象类不能创建对象 //2.创建Animal的子类Cat对象 Cat cc = new Cat(); cc.run(); }
3.3 抽象类的特征和注意事项
抽象类的特征:
有得有失!!
有得: 抽象类具备了含有抽象方法的能力
有失: 失去创建对象的能力
注意事项:
a.抽象类不能创建对象(Java规定的!!)
b.抽象类是有构造方法的,用于初始化类的成员变量
c.抽象类中不一定有抽象方法,但是含有抽象方法的类一定是抽象类(一般来说抽象类中是有抽象方法)
d.抽象类的子类必须重写抽象类的所有抽象方法,否则子类还是一个抽象类
e.抽象类的天生作用就是做父类,为子类提供模板
3.4 抽象类存在的意义
抽象类的天生作用就是做父类,为子类提供模板
3.5 第一个设计模式：模板模式(司机开车)
司机开车:
开门,点火,开车,熄火,关门
新司机:
开门,点火,两只手全是汗紧握方向盘,熄火,关门
老司机:
开门,点火,一只手接电话,一只手抽着烟,偶尔手指点点,熄火,关门
/**
* 司机类,父类,模板
*/
public abstract class Driver {
//开车
public void drive(){
System.out.println("开门...");
System.out.println("点火...");
kai();
System.out.println("熄火...");
System.out.println("关门...");
}
新司机: 两只手全是汗紧握方向盘
老司机: 一只手接电话,一只手抽着烟,偶尔手指点点
public abstract void kai();
}
/**
* 新司机
*/
public class NewDriver extends Driver {
@Override
public void kai() {
System.out.println("两只手全是汗紧握方向盘,慢慢开车..");
}
}
/**
* 老司机
*/
public class OldDriver extends Driver {
@Override
public void kai() {
System.out.println("一只手接电话,一只手抽着烟,偶尔手指点点,biu一下过去了..");
}
}
//测试类
public class TestDemo {
public static void main(String[] args) {
//1.新司机
NewDriver nd = new NewDriver();
nd.drive();
//2.老司机
OldDriver od = new OldDriver();
od.drive();
}
}
总结
继承:
a.继承的格式
public class 子类 extends 父类{
}
b.不能继承的内容
i.构造方法子类不能继承
ii.私有成员子类可以继承但是不能直接使用(间接使用,通过get/set方法使用)
c.继承后成员变量和成员方法的特点:
i.不同名,没有歧义
ii.同名时在子类中优先调用子类自己的成员
iii.我们可以使用关键字
super.变量名 访问父类的同名成员变量
super.方法名() 调用父类的同名成员方法
d.方法的重写
方法的重写:在继承关系中,子类有一个和父类除了方法体其他一模一样的方法,该方法称为重写的方法
什么时候需要重写:
当子类继承父类的方法后,发现父类的方法适用,那么子类就可以重写该方法
重写时可以使用@override帮助我们检测是否重写格式正确
e.super(..)
用于子类的构造方法第一行,调用父类的构造方法,具体是哪一个构造
由super(参数)中的参数决定
f.this(..)
用于本类的构造方法第一行,调用本类的其他构造方法,具体是哪一个构造
由this(...)中的参数决定
g.Java继承的特点:
只支持单继承,但是支持多层继承
抽象类:
a.抽象方法格式: public abstract void 方法();
抽象类格式: public abstract class 抽象类名{ 可能有抽象方法,也可以没有抽象方法}
b.抽象类怎么用?
使用子类继承抽象类,重写所有抽象方法后,子类才能创建对象
c.抽象类的意义:
给子类继承的,为子类提供的模板(模板设计模式)
扫一扫
311
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
