封装、继承、抽象类模板设计模式

最新推荐文章于 2022-10-27 20:09:37 发布

进击的decoder

最新推荐文章于 2022-10-27 20:09:37 发布

阅读量191

点赞数

文章标签： java

本文链接：https://blog.csdn.net/fftyyy/article/details/106793390

版权

这篇博客详细介绍了Java进阶的三个重要概念：封装、继承和抽象类。在封装部分，讲解了封装的步骤、构造器的作用、this关键字的应用以及匿名对象的使用。在继承章节，探讨了继承的概念、格式、特点以及重写的方法。在抽象类的部分，介绍了抽象类的定义、用途和模板模式的实际应用。

摘要由CSDN通过智能技术生成

java进阶第一天【封装、继承、抽象类模板设计模式】

第一章封装

1.1 封装

封装的步骤

a.给成员变量加上private
b.给成员变量添加get/set方法

封装的代码实现

public class Student {
    private String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1.2 构造器(构造方法)

构造器的作用

构造方法的作用是:初始化对象中的成员变量

构造器的格式

a.没有返回值,连void也不写
b.构造方法的名字必须和当前的类名是一致的

构造器的使用

new 构造方法(); //无参构造
new 构造方法(实际参数); //有参构造

1.3 this关键字

this关键字代表什么

this代表一个对象,代表当前对象(什么是当前:哪个对象调用方法,方法中的this就代表哪个对象)

this在代码中的应用

应用:在方法中区分成员变量和局部变量同名的情况

1.4 匿名对象

什么是匿名对象

什么是匿名对象: 是指只创建对象,但是不使用变量名来接收
    正常对象: 类名 变量名 = new 构造方法();
	匿名对象: new 构造方法();

匿名对象的使用场景

当一个对象,我们只需要使用一次时,就可以选择使用匿名对象(也可以使用正常对象)
public class TestDemo {
    public static void main(String[] args) {
        //匿名对象
        //1.键盘输入一个整数
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println(num);

        //2.此时我们就可以直接使用匿名对象
        int number = new Scanner(System.in).nextInt();
        System.out.println(number);
    }
}  
匿名对象的特点: 一个匿名对象只能使用一次

第二章继承

面向对象三大特点:

封装,继承,多态

引入案例

假如我们要定义如下类: 学生类,老师类和班主任类，分析如下：
1. 学生类 属性:姓名,年龄 行为:吃饭,睡觉,学习
2. 老师类 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书
3. 班主任 属性:姓名,年龄，薪水 行为:吃饭,睡觉，管理

2.1 继承的概念

所谓的继承是指: 在一个已知的类A基础上,创建一个新的类B的过程,称为继承
    专业名词:
		类A称为父类/基类/超类/SuperClass
        类B称为子类/派生类/SubClass

2.2 继承的格式

public class 父类{
 	//父类的一些成员   
}

public class 子类 extends 父类{
    //子类的一些成员
    //子类继承后父类,会自动拥有父类中一切可继承的东西
}

2.3 继承的案例

/**
 * 父类:人类
 */
public class Human {
    //年龄和姓名
    String name;
    int age;
    //吃饭和睡觉
    public void eat(){
        System.out.println("我吃吃吃...");
    }

    public void sleep() {
        System.out.println("我睡睡睡....");
    }
}
//子类1:学生类
public class Student extends Human{
    //学习
    public void study() {
        System.out.println("键盘敲烂,月薪过万...");
    }
}
//子类2:老师类
public class Teacher extends Human {
    //薪水
    double salary;
    //上课
    public void teach() {
        System.out.println("#%$%^*(....");
    }
}

继承好处总结

a.大大提高了代码的复用性
b.为多态提供了前提(明后天要学的)

2.4 子类不能继承的内容

a.子类是无法继承父类的构造方法
b.子类是可以继承父类的私有成员(private修饰的成员),
			但是子类无法"直接"使用他们,但是可以通过其他方法间接使用

2.5 继承后的特点——成员变量

a.如果子父类的成员变量不同名时,我们使用成员变量没有歧义
b.如果子父类的成员变量同名时,那么根据就近原则,优先访问子类自己的那个成员变量 
c.如果就想在子类中打印父类继承的那个同名的成员变量,可以使用关键字super.成员变量,直接访问父类继承的成员变量  
    
public class Fu {
//    int numFu = 10;
    int num = 10;
}

public class Zi extends Fu {
//    int numZi = 20;
    int num = 20;

    public void show() {
        //打印
//        System.out.println(numZi); //20
//        System.out.println(numFu); //10
        //打印
        //就近原则
        System.out.println(num); //20
        //在不删除子类的num情况下,能否打印父类的num,10呢???
        System.out.println(super.num); // 10
    }
}

2.6 继承后的特点——成员方法

a.如果子父类的成员方法不同名时,我们调用成员方法没有歧义
b.如果子父类的成员方法同名时,那么根据就近原则,优先调用子类自己的那个成员方法
c.如果就想在子类中调用父类继承的那个同名的成员方法,可以使用关键字super.成员方法名(),直接调用父类继承的成员方法
    
public class Fu {
//    public void showFu() {
//        System.out.println("父类的show方法...");
//    }
    public void show() {
        System.out.println("父类的show方法...");
    }
}

public class Zi extends Fu {
//    public void showZi() {
//        System.out.println("子类的show方法...");
//    }
    public void show() {
        System.out.println("子类的show方法...");
        super.show();
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //1.创建对象
        Zi zz = new Zi();
        //2.调用方法
//        zz.showZi();
//        zz.showFu();
        //3.调用同名方法
//        zz.show(); //就近原则
        //4.能不能在不删除子类的show方法情况下,直接调用父类的show方法???
//        zz.super.show();这种语法是错误的
        zz.show();
    }
}

2.7 重写的概念和应用

a.重载(overload):
		在同一个类中,方法名相同参数列表不同的方法,我们称为方法的重载
b.重写(override):
		在子父类关系中,子类从出现一个和父类除了方法体其他一模一样的方法,该方法称为方法的重写    
            
方法重写在实际开发中的应用:
	当子类继承父类后,发现某些方法功能不足或者不适用,那么子类就可以重写该方法,修改满足自己要求的方法体即可
        
/**
 * 老式手机
 */
public class OldPhone {
    String brand;
    int price;

    public void call() {
        System.out.println("打电话...");
    }

    public void sendMsg() {
        System.out.println("发送文字内容...");
    }
}

/**
 * 智能机
 */
public class Android extends OldPhone{
    //智能机继承了老式手机的发短信功能,但是功能不足,我们可以重写该方法
    public void sendMsg() {
//        System.out.println("发送文字内容..."); //500行代码
        super.sendMsg(); //调用父类的发文本的功能
        System.out.println("发送图片内容...");
        System.out.println("发送视频内容...");
    }
}

public class TestAndroid {
    public static void main(String[] args) {
        //1.创建一台智能机
        Android huawei = new Android();
        huawei.call();
        huawei.sendMsg();
    }
}
注意: 子类在重写父类的方法后,如果还需要用到父类的功能,不需要子类再写一遍,只需要通过super.方法名()调用即可

2.8 @Override注解

@Override: 方法重写的注解,让编译器帮助我们检查重写的方法是否正确
    
@Override //方法重写注解
public void sendMsg() {
    //        System.out.println("发送文字内容..."); //500行代码
    super.sendMsg(); //调用父类的发文本的功能
    System.out.println("发送图片内容...");
    System.out.println("发送视频内容...");
}

2.9 方法重写的注意事项

a.方法重写的前提是有继承关系(有实现关系)
b.子类方法重写父类方法，要求 子类方法权限 >= 父类方法的权限
    Java中有四个权限,从大到小分别是:
		public protected 默认的(defulet,不写) private
c.重写方法时,除了权限和方法体之外,其他的必须和父类方法一模一样(但是一般来说我们权限也写出一样)

2.10 继承后的特点——构造方法

构造方法特点介绍

a.构造方法子类能否继承??
    不能!!! 因为构造方法要求名和当前类名是一样的
b.继承后子类构造方法特点:
	子类所有构造方法的第一行都会使用super()先调用父类的无参构造器,先初始化父类中的成员变量，再执行自己的初始化操作

构造方法案例演示

public class Person {
    int age;
    String name;

    public Person() {
        System.out.println("Person的无参构造...");
    }
}

public class Student extends Person {
    //学号
    int id;

    //构造方法
    public Student(){
        //第一行: super();
        System.out.println("Student的无参构造...");
    }

    public Student(int id) {
        //第一行:super();
        System.out.println("Student的id构造...");
        this.id = id;
    }
}


public class TestDemo {
    public static void main(String[] args) {
        //1.创建对象
//        Student s1 = new Student();
        Student s2 = new Student(100);
    }
}

输出结果:
    Person的无参构造...
    Student的无参构造...
    
    Person的无参构造...
    Student的id构造...

构造方法总结

子类的任何一个构造,第一行默认(写和不写都行)都有一句代码: super()
代表调用父类的无参构造!

2.11 super(…)和this(…)

案例引入

public class TestDemo {
    public static void main(String[] args) {
        //1.创建对象
//        Student s1 = new Student();
        Student s2 = new Student(100);
        //2.打印
        System.out.println(s2.id); //初始化子类自己的成员变量
        System.out.println(s2.name);//父类无参构造初始化的默认值
        System.out.println(s2.age);//父类无参构造初始化的默认值
    }
}

super和this的用法格式

this.成员变量名 访问本类的成员变量
super.成员变量名 访问父类的成员变量
    
this.成员方法名() 调用本类的成员方法    
super.成员方法名() 调用父类的成员方法
 
super(); //子类的构造方法第一行默认调用父类无参构造
super(参数); //我们可以手动修改,调用父类的有参构造

this(); //可以在本类的某个构造中,调用本类的无参构造
this(参数);//可以在本类的某个构造中,调用本类的有参构造

super(…)用法演示

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 Student extends Person {
    //学号
    int id;
    //构造方法
    public Student(){
        //第一行默认是: super();
        //但是我们可以手动修改
        super(10,"张三");
        System.out.println("Student的无参构造...");
    }
    public Student(int id) {
        //第一行默认是: super();
        //但是我们可以手动修改
        super(20,"李四");
        System.out.println("Student的id构造...");
        this.id = id;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //1.创建对象
//        Student s1 = new Student();
        Student s2 = new Student(100);
        //2.打印
        System.out.println(s2.id); //初始化子类自己的成员变量
        System.out.println(s2.name);//父类无参构造初始化的默认值
        System.out.println(s2.age);//父类无参构造初始化的默认值
    }
}
输出结果:
	Person的全参构造....
    Student的id构造...
    100  子类构造初始化的
    李四  父类全参构造初始化的
    20	 父类全参构造初始化的

super(…)案例图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vFEcXXL8-1592305274320)(img/image-20200407113646869.png)]

this()用法演示

public class Dog {
    int age;
    String name;

    public Dog() {
//        System.out.println("无参构造");
        this(10,"旺财");
    }


    public Dog(int age) {
//        this();
        this(10,"旺财");
    }

    public Dog(String name) {
//        this();
        this(10,"旺财");
    }

    public Dog(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("Dog的满参构造...");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //要求: 无论用户通过哪个构造创建Dog对象,要求最终都使用无参构造
        //测试: this()
//        Dog d1 = new Dog();
//        Dog d2 = new Dog(10);
//        Dog d3 = new Dog("旺财");
//        Dog d4 = new Dog(10, "旺财");
        //要求: 无论用户通过哪个构造创建Dog对象,要求最终都全参构造
        Dog d1 = new Dog();
        Dog d2 = new Dog(10);
        Dog d3 = new Dog("旺财");
        Dog d4 = new Dog(10, "旺财");
    }
}

小结

a.子类构造第一句默认有句代码super(),调用父类无参构造,我们可以手动改写super(参数),调用父类的有参构造
b.this(参数)和super(参数)这两个都必须在第一行出现,所以不能同时调用   
c.this(参数)和super(参数)分别调用子类的和父类的有参构造,具体调用哪一个,根据参数决定
d.super(参数)作用调用父类的构造方法,初始化从父类继承的那些成员变量
e.this(参数)调用本类的其他有参构造方法

2.12 Java中继承的特点

a.Java只支持单继承，不支持多继承(一个类只能有一个亲爹)
b.Java中一个类可以有多个子类。(一个类可以有多个孩子)    
c.Java中类可以多层继承(一个子类只能有一个父类,但是其父类也可以有"爷爷"类)

第三章抽象类

3.1 抽象类的概念和引入

什么是抽象方法:
	一个方法只有方法的声明(头部),没有方法的具体实现(方法体),称为抽象方法
什么是抽象类:
	含有抽象方法的类一定是一个抽象类

3.2 abstract使用格式

抽象方法

public abstract void 方法名(参数);

抽象类

public abstract class 类名{
    //可以有正常方法
    //也可以有抽象方法
}

/**
 * 抽象类
 */
public abstract class Animal {
    //吃
    public abstract void eat();
}

抽象类的使用

a.抽象类无法创建对象
b.抽象类天生就是做爹的(天生就是给子类继承的)  
c.子类继承抽象类,必须重写抽象类中"所有的"抽象方法,否则子类还是一个抽象类  
    
/**
 * 抽象类
 */
public abstract class Animal {
    //吃
    public abstract void eat();
}
public class Dog extends Animal {
    //1.给子类Dog再加上abstract
    //2.子类Dog重写Animal中所有的抽象方法
    @Override
    public void eat() {
        System.out.println("狗喜欢舔着吃...");
    }
}
public class TestAnimal {
    public static void main(String[] args) {
        //1.创建抽象类Animal对象
        //抽象类是不能创建对象的
        //Animal an = new Animal();
        //2.创建抽象类的子类Dog对象
        Dog dd = new Dog();
        dd.eat();
    }
}

3.3 抽象类的特征和注意事项

抽象类的特点: 有得有失
a.抽象类得到了拥有抽象方法的能力
b.抽象类失去了创建对象的能力
除此之外,类中的其他成员(比如成员变量,成员方法,构造方法,静态方法等抽象类照常可以拥有)

注意事项:
a.抽象类不能创建对象(Java规定的)
b.抽象类里是有构造方法!!!(用于子类构造方法调用父类构造,给成员变量初始化值的) 
c.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类    
d.抽着类的子类,要么还是一个抽象类,要么重写所有的重写方法,否则,编译会报错!!
c.抽象类存在的意义: 给子类继承用的,体现模板思想
    抽象方法存在的意义: 强制子类必须重写,体现模板思想

3.4 抽象类存在的意义

给子类继承的,体现一种编程思想:模板思想

3.5 第一个设计模式：模板模式(司机开车)

设计模式: 前辈们为了方便解决各种各样的问题,总结出的一种套路
今天学习第一种设计模式: 模板模式
 
案例: 司机开车
    a.新司机
    	开车门
    	点火
    	两只手紧握方向盘,全是汗,小心翼翼的开...
    	熄火
    	关门
    b.老司机
    	开车门
    	点火
    	一只手拿着手机,一只手拿着鸡腿,偶尔下巴碰一下,大大咧咧开车...
    	熄火
    	关门
    
/**
 * 司机类
 */
public abstract class Driver {
    String name;
    int age;
    //开车
    public void drive() {
        System.out.println("开门..");
        System.out.println("点火..");
        //开车
        run();
        System.out.println("熄火..");
        System.out.println("关门..");
    }
    public abstract void run();
    //两只手紧握方向盘,全是汗,小心翼翼的开...
    //一只手拿着手机,一只手拿着鸡腿,偶尔下巴碰一下,大大咧咧开车...
}

public class NewDriver extends Driver {
    @Override
    public void run() {
        System.out.println("两只手紧握方向盘,全是汗,小心翼翼的开...");
    }
}
public class OldDriver extends Driver {
    @Override
    public void run() {
        System.out.println("一只手拿着手机,一只手拿着鸡腿,偶尔下巴碰一下,大大咧咧开车...");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //1.创建一个新司机对象
        NewDriver nd = new NewDriver();
        nd.drive();
        //2.创建一个老司机对象
        OldDriver od = new OldDriver();
        od.drive();
    }
}
输出结果:
    开门..
    点火..
    两只手紧握方向盘,全是汗,小心翼翼的开...
    熄火..
    关门..
        
    开门..
    点火..
    一只手拿着手机,一只手拿着鸡腿,偶尔下巴碰一下,大大咧咧开车...
    熄火..
    关门..

总结:

能够写出类的继承格式【重点】
   public class 子类 extends 父类{
       
   }
    
能够说出继承的特点【重点】
    a。单继承（一个子类只能有一个父类，一个父类可以有多个子类）
    b。多层继承（一个子类只能有一个父类，一个父类也可以有其父类）
    
能够说出子类调用父类的成员特点【重点】
    a。子父类成员不同名，没有问题
    b。子父类成员同名时，根据就近原则，优先调用子类的成员
    				我们也可以使用super.方法名()，直接调用父类的成员
    c.构造方法子类无法继承,但是在子类的所有构造第一行默认会调用父类的无参构造(使用super())
    
够说出方法重写的概念【重点】
    在继承的关系中,子类出现一个和父类除了方法体和修饰符,其他都一模一样的方法,此时子类中的方法称为方法重写
能够说出this可以解决的问题【重点】
    this可以解决局部变量和成员变量同名问题
能够说出super可以解决的问题【重点】
    super可以解决本类的成员和父类的成员同名问题
    
描述抽象方法的概念【重点】
    抽象方法: 只有方法声明,没有方法实现的方法(抽象方法要使用abstract修饰)
	抽象类: 如果类中含有抽象方法,该类一定是一个抽象类
        	如果类中不含有抽象方法,该类也可能是一个抽象类
写出抽象类的格式【重点】
    public abstract class 类名{
        //正常类具有的抽象类也就具有,就是不能创建对象
        //也可以写抽象方法,也可以不写抽象方法
    }
写出抽象方法的格式【重点】
    public abstract void 方法名(参数);    

    
能够说出父类抽象方法的存在意义【重点】
    抽象类和抽象方法存在的意义,一个让子类继承的,一个子类必须重写的,体现模板思想