栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

面向对象第三节

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

面向对象第三节

文章目录
  • 一.面向对象语言的三大特征---封装
    • 1.封装的概念
    • 2.封装的好处
    • 3.设计模式
      • 单例模式
        • 1.懒汉单例
        • 2.饿汉单例(急切式单例)
  • 二.面向对象语言的三大特征---继承
    • 1.什么是继承
    • 2.什么时候使用继承
    • 3.几个名词
    • 4.继承的传递性
    • 5.注意事项
    • 6.继承中的构造方法
      • super关键字
      • 继承中的构造方法
    • 7.方法的重写(OverRide)
      • 1.何时需要方法重写
      • 2.如何重写方法
      • 3.方法重写规则
  • 三.抽象类
    • 1.抽象方法
      • 1.什么是抽象方法
      • 2.什么时候需要抽象方法
    • 2.抽象类
      • 1.什么是抽象类
      • 2.抽象类特点

一.面向对象语言的三大特征—封装 1.封装的概念

将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问 .

2.封装的好处

1.隐藏类的细节

2.只能通过规定方法访问

3.方便加入控制语句

4.方便修改实现

//属性私有化就是封装的一种表现
package morning ;

public class SingLeton {

    private String a;
   
    public String getA() {
       return a;
    }

    public void setA(String a) {
        if(a != "qq") {
            this.a = a;
        }
    }
}
3.设计模式

设计模式:前人总结出解决某些问题的最佳方案

单例模式

需要某一个类在整个应用程序中,只能创建一个对象.

解决思路:

第一步:将构造方法私有化,使得在程序其他地方不能随意创建对象.

第二步:向外界提供一个方法,用来获得创建的唯一一个对象,在类的内部控制起来比较方便.

1.懒汉单例

程序如下:

package morning ;

//实现只能创建一个对象,
// 懒汉单例

public class SingLeton {

    private static SingLeton singLeton;//私有的静态SingLeton变量.私有的变量将其封装起来.因为在创建对象前要进行判断,因此需要static


    //将构造方法私有化
    private SingLeton(){

    }

    
    public static SingLeton get(){
        if(singLeton == null){//如果未进行初始化
             singLeton = new SingLeton();//创建对象,赋给地址
        }
        return  singLeton;
    }
}

懒汉单例存在线程安全问题.

2.饿汉单例(急切式单例)

程序如下:

package morning;

//饿汉单例(急切式单例)
public class SingLeton1 {

    //创建一个对象,因为是静态,只加载一次,储存在方法区
    static  SingLeton1 singLeton = new SingLeton1();

    //构造方法私有化
    private SingLeton1(){

    }

    //向外界提供得到指向对象的变量方法
    public static SingLeton1 getSingLeton(){
        return singLeton;
    }

    public static void main(String[] args) {
        System.out.println(SingLeton1.getSingLeton());
    }
}

饿汉单例不存在线程安全问题.

二.面向对象语言的三大特征—继承 1.什么是继承

继承是面向对象程序设计不可缺少的设计思想,是实现代码可重
用的根基,是提高代码可扩展性的主要途径.

继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行为(重用性),并能扩展新的能力(扩展性).

2.什么时候使用继承

符合**[is-a]**的关系就可以使用继承

比如:猫是动物,狗是动物.那么猫和狗就可以继承于动物类.

动物类就是猫类和狗类的父类.在创建的时候,将子类共有的属性和行为放在父类中.

ackage afternoon;

public class Animal {

    private String name;
    private int age;

    //无参的构造方法
    public Animal(){

    }

    //共有的行为
    public  void  eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }

    //提供可修改的方法
    public void show(){
        System.out.println(name+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 afternoon;


public class Cat extends Animal{

}
ackage afternoon;

public class Test {
    
    public static void main(String[] args) {
        
        Cat cat = new Cat();
        cat.setName("大黑");
        cat.setAge(9);
        cat.sleep();
        cat.eat();
        cat.show();

    }
}

继承是代码重用的一种方式.

3.几个名词

就如上面的两段代码

猫类是动物类的子类,动物类是猫类的父类.

猫类是动物类的派生类,动物类是猫类的基类.

4.继承的传递性

C类从B类继承,B类又从A类继承.

那么C类就具有B类和A类的所有非私有属性和非私有方法.

在上面代码的基础上我们继续添加一个类继承猫类

package afternoon;

public class Mimi extends Cat{

    private  String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}
package afternoon;

public class Test {
    
    public static void main(String[] args) {
        
        Mimi mimi = new Mimi();
        mimi.setColor("黄色");
        System.out.println(mimi.getColor());
        mimi.setName("小米 ");
        mimi.setAge(6);
        mimi.show();

    }
}
5.注意事项

1.当一个没有继承任何一个类时,jvm会默认让类继承**Object类,**Object类是Java为所有类提供的基类.

2.在Java中使用extends关键字来表示继承关系.

3.Java不支持多继承,单继承使得Java的继承关系很简单,一个类只能有一个直接父类.

4.继承之后子类可以调用父类的所有非私有属性和非私有方法.

6.继承中的构造方法 super关键字

super关键字的用途:

(与this相对应,this代表的是当前对象.super代表的是父类的.)

我们可以使用super关键字访问父类成员

1.使用super.成员变量名来引用父类成员变量

2.使用super.方法名(参数列表)访问父类的方法

3.使用super.构造方法(参数列表)访问父类构造方法

注意事项:

不要误认为super是父类对象,在创建子类对象时,不会创建父类对象.只会把父类的信息加载到子类对象中存储.

继承中的构造方法

子类构造方法会先调用父类构造方法.

使用super关键字调用父类任意一个构造方法,必须写在第一行.

  为什么必须写到第一行
  因为子类创建对象后,子类可以访问父类的信息.也就是说new这个动作执行后,有可能对其中的属性做出了操作.所以在初始化子类之前,必须先初始化父类.也就是先调用父类的构造方法.

如果子类的构造方法中没有显式的调用父类构造方法,则系统默认在子类构造方法第一行调用父类无参数的构造方法.

7.方法的重写(OverRide)

重写也叫覆盖或者复写.

1.何时需要方法重写

当父类的方法实现不能满足子类需求时,可以对方法进行重写

2.如何重写方法

在子类中可以根据需要对从父类继承来的方法进行重写


public  void  eat(){
        System.out.println("吃饭");
    }

@Override//@Override标签表示此方法是重写的
    public  void  eat(){
        System.out.println("猫吃饭");
    }

这就是重写方法

3.方法重写规则

1.方法名相同,参数列表相同

2.返回值类型相同

3.访问权限不能小于父类权限

注意:

构造方法,静态方法不能重写,成员变量不存在重写

三.抽象类 1.抽象方法 1.什么是抽象方法

抽象方法是一种特殊的方法:只有声明,没有具体的实现.

例如:
public  abstract void  eat();//抽象的方法

抽象方法必须用abstract来修饰.

2.什么时候需要抽象方法

可能有很多子类的行为与父类的行为不同.比如说吃,有的吃肉,有的吃草…那么在父类定义的吃的行为就很多余,因为在子类还需要重写.这个时候就可以对方法进行抽象.

抽象方法没有方法体,如果有抽象方法,需要将类定义为抽象类.

2.抽象类 1.什么是抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象(也就是有抽象方法),这样的类就是抽象类.

注意:抽象类不一定有抽象方法.有抽象方法一定是抽象类.

抽象类除了不能实例化对象之外(因为有抽象方法不能实例化),类的其他功能依然存在,成员方法,成员变量,构造方法…

如我们提到的动物类

package afternoon.chouxiang;

public abstract class Animal {//抽象的类

    private String name;
    private int age;

    public  abstract void  eat();//抽象的方法

    public void sleep(){
        System.out.println("躺着睡觉");
    }

    public Animal(){

    }

    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;
    }
}

**用abstract修饰的类就是抽象类.**如果某个类包含抽象方法,那么该类必须定义为抽象类.

2.抽象类特点

**抽象类不能被实例化.但可以有构造方法.**因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象.

抽象类只能用作基类,表示的是一种继承关系.继承抽象类的非抽象类必须实现其中的所有抽象方法,而已实现方法的参数、返回值要和抽象类中的方法一样.否则,该类也必须声明为抽象类.

比如:

package afternoon.chouxiang;

//狗类继承动物类,要么将狗类也抽象化,要么对抽象方法进行重写
public class Dog extends Animal{

    @Override
    public  void  eat(){
        System.out.println("狗会吃饭");
    }

}

抽象类,抽象方法,在软件开发过程中都是设计层面的概念.也就是说,设计人员会设计出抽象类,抽象方法.程序员都是继承这些抽象并覆盖抽象方法,实现具体功能.

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/937438.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号