从零开始学习 Java：简单易懂的入门指南之抽象类接口内部类（十一）

面向对象进阶（抽象类&接口&内部类）

  • 第一章 抽象类
    • 1.1 概述
      • 1.1.1 抽象类引入
    • 1.2 abstract使用格式
      • 1.2.1 抽象方法
      • 1.2.2 抽象类
      • 1.2.3 抽象类的使用
    • 1.3 抽象类的特征
    • 1.4 抽象类的细节
    • 1.5 抽象类存在的意义
  • 第二章 接口
    • 2.1 概述
    • 2.2 定义格式
    • 2.3 接口成分的特点
      • 2.3.1.抽象方法
      • 2.3.2 常量
      • 2.3.3 案例演示
    • 2.4 基本的实现
      • 2.4.1 实现接口的概述
      • 2.4.2 实现接口的格式
      • 2.4.3 类实现接口的要求和意义
      • 2.4.4 类与接口基本实现案例
      • 2.4.5 类与接口的多实现案例
    • 2.5 接口与接口的多继承
    • 2.6扩展：接口的细节
  • 第三章 内部类
    • 3.1 概述
      • 3.1.1 什么是内部类
      • 3.1.2 什么时候使用内部类
    • 3.2 内部类的分类
    • 3.3 成员内部类
    • 3.4 成员内部类的细节
    • 3.5 成员内部类面试题
    • 3.6 成员内部类内存图
    • 3.7 静态内部类
    • 3.8 局部内部类
    • 3.9 匿名内部类【重点】
      • 3.9.1 概述
      • 3.9.2 格式
      • 3.9.2 什么时候用到匿名内部类
      • 3.9.3 匿名内部类前提和格式
      • 3.9.4 使用方式
      • 3.9.5 匿名内部类的特点
      • 3.9.6 匿名内部类的使用场景

第一章 抽象类

1.1 概述

1.1.1 抽象类引入

​ 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

  • 抽象方法 ： 没有方法体的方法。
  • 抽象类：包含抽象方法的类。

1.2 abstract使用格式

abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

1.2.1 抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

代码举例：

public abstract void run()；

1.2.2 抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

abstract class 类名字 { }

代码举例：

public abstract class Animal {public abstract void run()；
}

1.2.3 抽象类的使用

要求：继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。

代码举例：

// 父类,抽象类
abstract class Employee {private String id;private String name;private double salary;public Employee() {}public Employee(String id, String name, double salary) {this.id = id;this.name = name;this.salary = salary;}// 抽象方法// 抽象方法必须要放在抽象类中abstract public void work();
}// 定义一个子类继承抽象类
class Manager extends Employee {public Manager() {}public Manager(String id, String name, double salary) {super(id, name, salary);}// 2.重写父类的抽象方法@Overridepublic void work() {System.out.println("管理其他人");}
}// 定义一个子类继承抽象类
class Cook extends Employee {public Cook() {}public Cook(String id, String name, double salary) {super(id, name, salary);}@Overridepublic void work() {System.out.println("厨师炒菜多加点盐...");}
}// 测试类
public class Demo10 {public static void main(String[] args) {// 创建抽象类,抽象类不能创建对象// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
//		Employee e = new Employee();
//		e.work();// 3.创建子类Manager m = new Manager();m.work();Cook c = new Cook("ap002", "库克", 1);c.work();}
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

1.3 抽象类的特征

抽象类的特征总结起来可以说是 有得有失

有得：抽象类得到了拥有抽象方法的能力。

有失：抽象类失去了创建对象的能力。

其他成员（构造方法，实例方法，静态方法等）抽象类都是具备的。

1.4 抽象类的细节

不需要背，只要当idea报错之后，知道如何修改即可。

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

    理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

    理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

    理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

  4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

    理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

  5. 抽象类存在的意义是为了被子类继承。

    理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

1.5 抽象类存在的意义

​ 抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义。抽象类可以强制让子类，一定要按照规定的格式进行重写。

第二章 接口

2.1 概述

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的。

2.2 定义格式

//接口的定义格式：
interface 接口名称{// 抽象方法
}// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

2.3 接口成分的特点

在JDK7，包括JDK7之前，接口中的只有包含：抽象方法和常量

2.3.1.抽象方法

​ 注意：接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！
​ 按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。

2.3.2 常量

在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。

2.3.3 案例演示

public interface InterF {// 抽象方法！//    public abstract void run();void run();//    public abstract String getName();String getName();//    public abstract int add(int a , int b);int add(int a , int b);// 它的最终写法是：// public static final int AGE = 12 ;int AGE  = 12; //常量String SCHOOL_NAME = "程序员";}

2.4 基本的实现

2.4.1 实现接口的概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

2.4.2 实现接口的格式

/**接口的实现：在Java中接口是被实现的，实现接口的类称为实现类。实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{}

从上面格式可以看出，接口是可以被多实现的。大家可以想一想为什么呢？

2.4.3 类实现接口的要求和意义

  1. 必须重写实现的全部接口中所有抽象方法。
  2. 如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
  3. 意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范。

2.4.4 类与接口基本实现案例

假如我们定义一个运动员的接口（规范），代码如下：

/**接口：接口体现的是规范。* */
public interface SportMan {void run(); // 抽象方法，跑步。void law(); // 抽象方法，遵守法律。String compittion(String project);  // 抽象方法，比赛。
}

接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：

package com.itheima._03接口的实现;
/*** 接口的实现：*    在Java中接口是被实现的，实现接口的类称为实现类。*    实现类的格式:*      class 类名 implements 接口1,接口2,接口3...{***      }* */
public class PingPongMan  implements SportMan {@Overridepublic void run() {System.out.println("乒乓球运动员稍微跑一下！！");}@Overridepublic void law() {System.out.println("乒乓球运动员守法！");}@Overridepublic String compittion(String project) {return "参加"+project+"得金牌！";}
}

测试代码：

public class TestMain {public static void main(String[] args) {// 创建实现类对象。PingPongMan zjk = new PingPongMan();zjk.run();zjk.law();System.out.println(zjk.compittion("全球乒乓球比赛"));}
}

2.4.5 类与接口的多实现案例

类与接口之间的关系是多实现的，一个类可以同时实现多个接口。

首先我们先定义两个接口，代码如下：

/** 法律规范：接口*/
public interface Law {void rule();
}/** 这一个运动员的规范：接口*/
public interface SportMan {void run();
}

然后定义一个实现类：

/*** Java中接口是可以被多实现的：*    一个类可以实现多个接口: Law, SportMan** */
public class JumpMan implements Law ,SportMan {@Overridepublic void rule() {System.out.println("尊长守法");}@Overridepublic void run() {System.out.println("训练跑步！");}
}

从上面可以看出类与接口之间是可以多实现的，我们可以理解成实现多个规范，这是合理的。

2.5 接口与接口的多继承

Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口。大家一定要注意：

类与接口是实现关系

接口与接口是继承关系

接口继承接口就是把其他接口的抽象方法与本接口进行了合并。

案例演示：

public interface Abc {void go();void test();
}/** 法律规范：接口*/
public interface Law {void rule();void test();
}**  总结：*     接口与类之间是多实现的。*     接口与接口之间是多继承的。* */
public interface SportMan extends Law , Abc {void run();
}

2.6扩展：接口的细节

不需要背，只要当idea报错之后，知道如何修改即可。

关于接口的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

  1. 当两个接口中存在相同抽象方法的时候，该怎么办？

只要重写一次即可。此时重写的方法，既表示重写1接口的，也表示重写2接口的。

  1. 实现类能不能继承A类的时候，同时实现其他接口呢？

继承的父类，就好比是亲爸爸一样
实现的接口，就好比是干爹一样
可以继承一个类的同时，再实现多个接口，只不过，要把接口里面所有的抽象方法，全部实现。

  1. 实现类能不能继承一个抽象类的时候，同时实现其他接口呢？

实现类可以继承一个抽象类的同时，再实现其他多个接口，只不过要把里面所有的抽象方法全部重写。

  1. 实现类Zi，实现了一个接口，还继承了一个Fu类。假设在接口中有一个方法，父类中也有一个相同的方法。子类如何操作呢？

处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。
处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。

  1. 如果一个接口中，有10个抽象方法，但是我在实现类中，只需要用其中一个，该怎么办?

可以在接口跟实现类中间，新建一个中间类（适配器类）
让这个适配器类去实现接口，对接口里面的所有的方法做空重写。
让子类继承这个适配器类，想要用到哪个方法，就重写哪个方法。
因为中间类没有什么实际的意义，所以一般会把中间类定义为抽象的，不让外界创建对象

第三章 内部类

3.1 概述

3.1.1 什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。

3.1.2 什么时候使用内部类

一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用

  1. 人里面有一颗心脏。
  2. 汽车内部有一个发动机。
  3. 为了实现更好的封装性。

3.2 内部类的分类

按定义的位置来分

  1. 成员内部类，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
  2. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
  3. 局部内部类，类定义在方法内
  4. 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

3.3 成员内部类

成员内部类特点：

  • 无static修饰的内部类，属于外部类对象的。
  • 宿主：外部类对象。

内部类的使用格式：

 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

获取成员内部类对象的两种方式：

方式一：外部直接创建成员内部类的对象

外部类.内部类 变量 = new 外部类（）.new 内部类（）;

方式二：在外部类中定义一个方法提供内部类的对象

案例演示

方式一：
public class Test {public static void main(String[] args) {//  宿主：外部类对象。// Outer out = new Outer();// 创建内部类对象。Outer.Inner oi = new Outer().new Inner();oi.method();}
}class Outer {// 成员内部类，属于外部类对象的。// 拓展：成员内部类不能定义静态成员。public class Inner{// 这里面的东西与类是完全一样的。public void method(){System.out.println("内部类中的方法被调用了");}}
}方式二：
public class Outer {String name;private class Inner{static int a = 10;}public Inner getInstance(){return new Inner();}
}public class Test {public static void main(String[] args) {Outer o = new Outer();System.out.println(o.getInstance());}
}

3.4 成员内部类的细节

编写成员内部类的注意点：

  1. 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
  2. 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
  3. 创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见3.6节的内存图）

详解：

​ 内部类被private修饰，外界无法直接获取内部类的对象，只能通过3.3节中的方式二获取内部类的对象

​ 被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象

​ 内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。

​ 内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

3.5 成员内部类面试题

请在?地方向上相应代码,以达到输出的内容

注意：内部类访问外部类对象的格式是：外部类名.this

public class Test {public static void main(String[] args) {Outer.inner oi = new Outer().new inner();oi.method();}
}class Outer {	// 外部类private int a = 30;// 在成员位置定义一个类class inner {private int a = 20;public void method() {int a = 10;System.out.println(???);	// 10   答案：aSystem.out.println(???);	// 20	答案：this.aSystem.out.println(???);	// 30	答案：Outer.this.a}}
}

3.6 成员内部类内存图

在这里插入图片描述

3.7 静态内部类

静态内部类特点：

  • 静态内部类是一种特殊的成员内部类。
  • 有static修饰，属于外部类本身的。
  • 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
  • 拓展1:静态内部类可以直接访问外部类的静态成员。
  • 拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。
  • 拓展3:静态内部类中没有银行的Outer.this。

内部类的使用格式：

外部类.内部类。

静态内部类对象的创建格式：

外部类.内部类  变量 = new  外部类.内部类构造器;

调用方法的格式：

  • 调用非静态方法的格式：先创建对象，用对象调用
  • 调用静态方法的格式：外部类名.内部类名.方法名();

案例演示：

// 外部类：Outer01
class Outer01{private static  String sc_name = "程序";// 内部类: Inner01public static class Inner01{// 这里面的东西与类是完全一样的。private String name;public Inner01(String name) {this.name = name;}public void showName(){System.out.println(this.name);// 拓展:静态内部类可以直接访问外部类的静态成员。System.out.println(sc_name);}}
}public class InnerClassDemo01 {public static void main(String[] args) {// 创建静态内部类对象。// 外部类.内部类  变量 = new  外部类.内部类构造器;Outer01.Inner01 in  = new Outer01.Inner01("张三");in.showName();}
}

3.8 局部内部类

  • 局部内部类 ：定义在方法中的类。

定义格式:

class 外部类名 {数据类型 变量名;修饰符 返回值类型 方法名(参数列表) {// …class 内部类 {// 成员变量// 成员方法}}
}

3.9 匿名内部类【重点】

3.9.1 概述

匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类了。

3.9.2 格式

new 类名或者接口名() {重写方法;
};

包含了：

  • 继承或者实现关系

  • 方法重写

  • 创建对象

所以从语法上来讲，这个整体其实是匿名内部类对象

3.9.2 什么时候用到匿名内部类

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用

是为了简化代码。

之前我们使用接口时，似乎得做如下几步操作：

  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法
interface Swim {public abstract void swimming();
}// 1. 定义接口的实现类
class Student implements Swim {// 2. 重写抽象方法@Overridepublic void swimming() {System.out.println("狗刨式...");}
}public class Test {public static void main(String[] args) {// 3. 创建实现类对象Student s = new Student();// 4. 调用方法s.swimming();}
}

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

3.9.3 匿名内部类前提和格式

匿名内部类必须继承一个父类或者实现一个父接口。

匿名内部类格式

new 父类名或者接口名(){// 方法重写@Override public void method() {// 执行语句}
};

3.9.4 使用方式

以接口为例，匿名内部类的使用，代码如下：

interface Swim {public abstract void swimming();
}public class Demo07 {public static void main(String[] args) {// 使用匿名内部类new Swim() {@Overridepublic void swimming() {System.out.println("自由泳...");}}.swimming();// 接口 变量 = new 实现类(); // 多态,走子类的重写方法Swim s2 = new Swim() {@Overridepublic void swimming() {System.out.println("蛙泳...");}};s2.swimming();s2.swimming();}
}

3.9.5 匿名内部类的特点

  1. 定义一个没有名字的内部类
  2. 这个类实现了父类，或者父类接口
  3. 匿名内部类会创建这个没有名字的类的对象

3.9.6 匿名内部类的使用场景

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

interface Swim {public abstract void swimming();
}public class Demo07 {public static void main(String[] args) {// 普通方式传入对象// 创建实现类对象Student s = new Student();goSwimming(s);// 匿名内部类使用场景:作为方法参数传递Swim s3 = new Swim() {@Overridepublic void swimming() {System.out.println("蝶泳...");}};// 传入匿名内部类goSwimming(s3);// 完美方案: 一步到位goSwimming(new Swim() {public void swimming() {System.out.println("大学生, 蛙泳...");}});goSwimming(new Swim() {public void swimming() {System.out.println("小学生, 自由泳...");}});}// 定义一个方法,模拟请一些人去游泳public static void goSwimming(Swim s) {s.swimming();}
}

后记
👉👉💕💕美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ 🌹🌹🌹

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/88871.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

机器学习 | Python实现KNN(K近邻)模型实践

机器学习 | Python实现KNN(K近邻)模型实践

机器学习 | Python实现KNN(K近邻)模型实践 目录 机器学习 | Python实现KNN(K近邻)模型实践基本介绍模型原理源码设计学习小结参考资料基本介绍 一句话就可以概括出KNN（K最近邻算法）的算法原理：综合k个“邻居”的标签值作为新样本的预测值。更具体来讲KNN分类过程，给定一个训…
阅读更多...
第二十一章 重要HL7操作场景 - HL7批量消息

第二十一章 重要HL7操作场景 - HL7批量消息

文章目录 第二十一章 重要HL7操作场景 - HL7批量消息支持的批处理格式处理传入的批次文档批处理模式自定义出库批量处理 第二十一章 重要HL7操作场景 - HL7批量消息 Production品支持 HL7 中的嵌套子文档（批处理格式）。每个子文档本身就是一个虚拟文档。…
阅读更多...
【设计模式】MVC 模式

【设计模式】MVC 模式

MVC 模式代表 Model-View-Controller（模型-视图-控制器） 模式。这种模式用于应用程序的分层开发。 Model（模型） - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。View&#xff…
阅读更多...
Python爬虫——requests_cookie登陆古诗文网

Python爬虫——requests_cookie登陆古诗文网

寻找登陆需要的参数 __VIEWSTATE:aiMG0UXAfCzak10C7436ZC/RXoZbM2lDlX1iU/4wjjdUNsW8QUs6W2/3M6XIKagQZrC7ooD8Upj8uCnpQMXjDAp6fS/NM2nGhnKO0KOSXfT3jGHhJAOBouMI3QnlpJCQKPXfVDJPYwh169MGLFC6trY __VIEWSTATEGENERATOR: C93BE1AE from: http://so.gushiwen.cn/user/collect.…
阅读更多...
泰卦-地天卦

泰卦-地天卦

前言：否极泰来，但在易经里是泰卦在前，让我们分析下在否所期待否极后的泰卦是什么样的？本篇博客分析泰卦的卦辞和爻辞。 卦辞 小往大来，吉，亨。 篆曰：泰，小往大来，吉亨。…
阅读更多...
面试热题（合并两个有序列表）

面试热题（合并两个有序列表）

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 合并链表这类型题也是比较经典的题了，因为链表是由指针相互指向而确定位置，所以我们只需要改变某些节点的指针便可以做到对链表进行排序 今天这个方法…
阅读更多...
C++小游戏贪吃蛇源码

C++小游戏贪吃蛇源码

graphics.h是针对DOS下的一个C语言图形库 (c也可以) 目前支持下载此头文件的常用的有两种: 1. EGE (Easy Graphics Engine)2. EasyX Graphics LibraryEGE, 全名Easy Graphics Engine, 是windows下的简易绘图库，是一个类似BGI(graphics.h)的面向C/C语言新手的图形库…
阅读更多...
APP外包开发的iOS开发语言

APP外包开发的iOS开发语言

学习iOS开发需要掌握Swift编程语言和相关的开发工具、框架和技术。而学习iOS开发需要时间和耐心，尤其是对于初学者。通过坚持不懈的努力，您可以逐步掌握iOS开发技能，构建出功能丰富、优质的移动应用。今天和大家分享学习iOS开发的一些建议方法…
阅读更多...
掌握Python的X篇_32_使用python编辑pdf文件_pdfrw

掌握Python的X篇_32_使用python编辑pdf文件_pdfrw

本篇介绍利用python操作pdf文件，我们平时也会有合并和拆分pdf的需求，此时我们就可以使用本节内容。 文章目录 1. pdfrw的安装2. 切分pdf文件3. pdfrw官网及实现一版四面的实例 1. pdfrw的安装 pip install pdfrw官网地址：https://github.co…
阅读更多...
机器学习深度学习——常见循环神经网络结构（RNN、LSTM、GRU）

机器学习深度学习——常见循环神经网络结构（RNN、LSTM、GRU）

👨‍🎓作者简介：一位即将上大四，正专攻机器学习的保研er 🌌上期文章：机器学习&&深度学习——RNN的从零开始实现与简洁实现 📚订阅专栏：机器学习&&深度学习 希望文章…
阅读更多...
ETLCloud+MaxCompute实现云数据仓库的高效实时同步

ETLCloud+MaxCompute实现云数据仓库的高效实时同步

MaxCompute介绍 MaxCompute是适用于数据分析场景的企业级SaaS（Software as a Service）模式云数据仓库，以Serverless架构提供快速、全托管的在线数据仓库服务，消除了传统数据平台在资源扩展性和弹性方面的限制，最小化用…
阅读更多...
PyQt5的信号与槽函数

PyQt5的信号与槽函数

目录 一、介绍 二、一个信号连接一个槽 三、一个信号连接多个槽 四、多个信号连接一个槽 五、自定义信号 1、创建自定义信号 2、让自定义信号携带值 一、介绍 在下图中 （1）widget就是PyQt中的控件对象。其实就是组件（2）…
阅读更多...
CNN之图像识别

CNN之图像识别

文章目录 1. 图像识别1.1 模式识别1.2 图像识别的过程1.3 图像识别的应用 2. 深度学习发展2.1 深度学习为何崛起2.2 分类与检测2.3 常见的卷积神经网络 3. VGG3.1 VGG163.2 VGG16的结构：3.3 使用卷积层代替全连接3.4 1*1卷积的作用3.5 VGG16代码示例 4. 残差模型-Re…
阅读更多...
MATLAB图论合集（一）基本操作基础

MATLAB图论合集（一）基本操作基础

本帖总结一些经典的图论问题，通过MATLAB如何计算答案。近期在复习考研，以此来巩固一下相关知识——虽然考研肯定不能用MATLAB代码哈哈，不过在实际应用中解决问题还是很不错的，比C易上手得多~ 图论中的图（Graph&#xf…
阅读更多...
Offset Explorer

Offset Explorer

Offset Explorer 简介下载安装 简介 Offset Explorer（以前称为Kafka Tool）是一个用于管理和使Apache Kafka 集群的GUI应用程序。它提供了一个直观的UI，允许人们快速查看Kafka集群中的对象以及存储在集群主题中的消息。它包含面向开发人员和管…
阅读更多...
深入理解MVVM架构模式

深入理解MVVM架构模式

原文合集地址如下，有需要的朋友可以关注 本文地址 MVVM原理 MVVM是一种用于构建用户界面的软件架构模式，它的名称代表着三个组成部分：Model（模型）、View（视图）和ViewModel（视图模…
阅读更多...
tkinter+爬虫+pygame实现音乐播放器

tkinter+爬虫+pygame实现音乐播放器

文章目录 前文安装模块示意图爬虫完整代码pygametkinter完整代码结尾前文 本文将涉及爬虫(数据的获取)，pygame(音乐播放器)，tkinter(界面显示)，将他们汇聚到一起制造一个音乐播放器，欢迎大家的订阅。 安装模块 pip install requests,parsel,lxpy,pygame 示意图
阅读更多...
19. python从入门到精通——Web编程

19. python从入门到精通——Web编程

HTTP协议 HTTP协议的常用方法 方法 描述 GET 请求指定的页面信息，并返回实体主体。 POST 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。 …
阅读更多...
WebAPIs 第四天

WebAPIs 第四天

1.日期对象 2.节点操作 3.M端事件 4.JS插件 一.日期对象 实例化时间对象方法时间戳 日期对象：用来表示时间的对象 作用：可以得到当前系统时间 1.1 实例化 ① 概念：在代码中发现了new关键字时，一般将这个操作称为实例化 …
阅读更多...
Go 异步任务

Go 异步任务

Go 异步任务 异步任务在开发中很常见，用来做解耦。本文介绍一下异步队列的实现的几个问题，并且结合三方库实现来分析。 有下面的几个关键点: 用户代码（任务）如何封装数据的存放（数据存放在哪里？就是一个…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023