java面向对象继承，抽象类，接口，多态的笔记

最新推荐文章于 2023-12-10 12:50:26 发布

Lantern liu

最新推荐文章于 2023-12-10 12:50:26 发布

阅读量163

点赞数 1

分类专栏： java 文章标签： java笔记

本文链接：https://blog.csdn.net/weixin_43857959/article/details/100991172

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

对象的初始化过程

1、执行main函数->

2、找到.class文件并加载到内存中->

3、执行静态代码块,给.class类进行初始化->

4、堆内存开辟空间，默认初始化（null，0）->

5、对属性进行显示初始化->

6、对对象进行构造代码块初始化（无名称方法）->

7、对对象进行构造函数初始化（赋值）

8、将内存地址赋给栈内存中的对象变量

对象调用成员的过程

方法区（共享区）

存储类中的数据，方法，优先于对象存在

对象一定在堆内存

单例设计（三步走）

单例（饿汉式）(安全简单、建议使用)、（解决一个类在内存在值存在一个对象）

1、为了避免其他程序过多的建立该类对象，先禁止其他程序建立该类对象

2、为了让其他程序可以访问该类对象，只好在奔雷中自定义一个对象

3、为了方便访问，提供一些访问方式，比如定义一个方法，返回对象

class Sinlge
{
    private static Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {
        return s;
    }    
    
}

单例（懒汉式）

1、

class Sinlge
{
    private static Single s = null
    private Single(){};
    public static synchronized（防止cup切换过程中多次生成对象） Single getInstance()
    {
        if (s==null)
            s = new Single();
        return s;
    }    
}
synchronized效率变低

聚集（has a）

聚合组合

继承

优点：提高复用性、让类之间产生关系，有了关系，才拥有多态的特性

注意：不要为了获取其他类的功能简化代码而继承必须类之间有所属关系

在具体调用时一、要创建最子类的对象二、创建子类对象可以使用更多的功能，包括基本的，特有的

当子类合父类具有同名变量的时候，访问本类对象用this，访问父类对象用super

覆盖（重写）

注意：一、子类重写父类，必须确保子类权限大于等于父类，才可以重写，否则编译失败二、静态只能重写静态（先加载静态）

在对子类进行初始化时，父类的构造函数也会初始化，那是因为在子类的构造函数第一行隐式语句super（） SUPER会访问父类中空参数的构造函数，所有子类中构造函数的第一行都是super（）若父类无空函数参数，则不能使用隐式语句，必须亲自写

为什么一定要访问父类的构造函数

因为父类数据子类可以直接获取，所以子类对象建立时，需要先查看如何对这些数据进行初始化。

class Person
{
    private String name;
    Person(String name)
    {
        thi.name = name;
    }
}
class Student
{
    Student(String name)
    {
        super(name);//当父类构造函数有参数时不能使用隐式语句super()
    }
}
//super语句一定要用在过谁啊函数第一行

结论：子类所有的构造函数，默认都会访问父类中空参数的构造函数，因为子类中的每一个构造函数内第一行都存在super（）当然：子类的构造函数第一行也可以手动指定this语句来访问本类的构造函数。子类中至少有一个构造函数会访问父类的构造函数（子类的实例化过程）

final关键字（修饰类函数变量）

为了避免被子类继承，被子类复写功能

被final修饰的方法不能be复写，被final修饰的变量的是常量，只能赋值一次（成员变量，局部变量）

抽象类

abstract class Student
{
    abstract void show();
}

抽象方法必须定义在抽象类中

抽象方法和抽象类一定得用abstract修饰

抽象类不能被new创建，抽象类中的方法要被使用，必须由子类复写所有的抽象方法，建立子类对象调用，如子类只覆盖部分抽象方法。该子类还是一个抽象类

父类只做出大概的需求，由子类具体实现

强迫子类复写某些内容

特殊：抽象类可以不定义抽象方法，只是为了不让该类建立对象

模板方法设计模式

在定义功能时，有部分功能不确定，确定的功能调用不确定的功能，这时将不确定的功能暴露出去，有该类的子类完成

abstract class GetTime
{
    public final void gettime()
    {
        long start = System.currentTimeMills();
        
        runcode();
        
        long end = System.currentTimeMills();
        
        System.out.println("毫秒:"+(end - start));
    }
    
    public abstarct void runcode();
}
class SubTime extends GetTime
{
    public void runcode()
    {
        for (int x = 0;x<1000;x++)
        {
            System.out.println(x);
        }
    }
}

class TemplateDemo 
{
    public static void main(String[] args)
    {
        GetTime gt = new GetTime();
        gt.gettime();
    }
}

接口（interface）

（初期理解）抽象类里面的方法都是抽象的可以表现为接口, 子类需要将抽象类中的抽象方法全部覆盖后，子类才可以实例化

接口中常见定义常量：public static final 方法：public abstract （只要定义了interface会自己增加public、static、abstract）

class Test implements Inter{ }

接口可以被类多实现（没有方法主体，可以被子类任意定义）（但是不能同时继承多个返回类型不同的同名方法）

一个类可以继承父类并且实现另一接口

接口可以继承接口（多继承）

interface A 
{
    void methodA();
}
interface B
{
    void methodB();
}
interface C extends B
{
    void methodC()
}

接口之间可以多继承

接口的特点

1、暴露规则

2、提高功能扩展性

3、降低耦合性

基本功能定义在类中，扩展功能定义在接口中

接口的巧妙应用

//此处接口用于扩展对象的功能（功能不是基本功能，而是拓展功能，即不是每一个对象都具备）
abstract class Student 
{
    abstract void study();
    void sleep()
    {
        System.out.println("sleep");
    }
}
inteface Smoking 
{
    void smoke();
}
class zhangsan extends Students impletemnts Smoking
{
    void study(){}
    public void smoke(){}
}

多态（提高代码扩展性）（统一操作多个对象）

父类引用指向了自己的子类对象

动物：猫

猫 x = new 猫（）；

动物 x = new 猫（）；

1、多态的体现：父类的引用指向了自己的子类对象，父类的引用也可以接受自己的子类对象

2、多态的前提：必须是类与类之间哟关系，要么继承，要么实现，通常还有一个前提，存在覆盖

3、多态的好处：多态的出现大大的提高了程序的扩展性

4、多态的弊端：提高了扩展性，但是只是使用父类的引用访问父类父类中的成员

多态转型：向上转型，向下转型

Animal a = new Animal();   //向上转型
Cat c = (Cat)a;  //向下转型
判断
if（c instanceof Cat）
{
    dwdwwdwwdw
}

多态中成员的特点

在多态中成员函数（非静态）（非静态有重写的特性）的特点：

在编译时期：参阅引用变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败。

在运行时期：参阅对象所属的类中的是否有调用的方法

成员函数在多态调用时，编译时看左边，运行时看右边

===============================================

静态只参考引用所属

在多态中，静态成员函数的特点：无论编译和运行，都参考左边

在多态中成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）（在内存中去找父类的变量）

===============================================

多态的主板示例

interface PCI
{
    public coid open();
    public void close();
}
class NetCard implements PCI
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close")
    }
}   //接口的出现增加了功能的扩展性，多态的应用提高程序扩展性
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
        
    }
    public void usePCI(PCI p) //接口型引用指向自己的子类对象
    {   
        if(p!=null)
        {
        p.open();
        p.close();
        }
    }
}
class DuoTaiDemo5
{
    public static void main(String[] args)
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null
        mb.usePCI(new NetCard())
    }
}

多态扩展的示例

需求：对于数据库的操作

数据：用户信息 1、连接数据库（JDBC）2、操作数据库（crud）3、关闭数据库连接

在这里插入图片描述

中间多了个数据库操作接口

Lantern liu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java面向对象继承，抽象类，接口，多态的笔记

对象的初始化过程1、执行main函数->2、找到.class文件并加载到内存中->3、执行静态代码块,给.class类进行初始化->4、堆内存开辟空间，默认初始化（null，0）->5、对属性进行显示初始化->6、对对象进行构造代码块初始化（无名称方法）->7、对对象进行构造函数初始化（赋值）8、将内存地址赋给栈内存中的对象变量对象调用成员的过...
复制链接

扫一扫