Java继承

方法重写是Java语言多态的特性,必须满足以下条件

  1. 在子类中,方法名称与父类方法名称完全相同
  2. 方法的参数个数和类型完全相同,返回类型完全相同
  3. 方法的访问修饰符访问级别不低于父类同名方法的访问级别
  4. 在方法上添加@override注释,如果报错说明不是重写

方法重写限制

  1. final修饰的父类方法在子类中不能被重写
  2. static修饰的父类方法在子类中不能被重写,只能覆盖

super关键字

  1. super关键字和this类似,super修饰的是父类的对象,如super();调用的是父类的默认无参构造器

Java抽象类

抽象类特点

  1. 抽象类通常应包含抽象方法,也可以包含非抽象方法
  2. 抽象类不能使用final关键字修饰
  3. 抽象类自身不能够实例化
  4. 抽象类就是用来被继承的

抽象类的继承

  1. 子类必须实现父类所有的抽象方法
  2. 如果子类已经override实现父类的抽象方法,间接子类可以不用实现该方法。

适配器

  1. 定义一个适配器,类名+Adapator。比如MamalAdapator。继承给父类所有的方法一个空的实现。后面实例的类继承这个适配器,就可以选择性的重写实现部分父类的方法而不会报错。
  2. 抽象类只提供一个抽象方法然后供子类去继承和重写override,然后特别是override的这个功能,可以做到比如Dog.eat,Cat.eat,不同的类,有不同的方法实现,但是方法名称都相同,给开发提供了极大的灵活性,后面的程序员接手开发的时候,比如需要再新增Tiger.eat,只需要再写一个Tiger类继承父类再override他的eat方法就可以了。
/**
* 1 使用Eclipse 工具建立一个普通Java控制台应用程序, 自定义一个类继承Counter 类,
* 并根据理解定义在Counter类中定义的抽象方法对父类的抽象方法进行实现,体会普通类继承
* 抽象类必需做什么? 不同子类在继承Counter抽象类并实现抽象方法时的算法和什么有关.
*/ public class Test {
public static void main(String[] args) {
//用父类的类型去new一个子类
Counter cou = new Add();
//用父类的类型去调用子类的addition方法并实现
System.out.println("3+9的和是"+cou.addition(3,9));
}
}
/**
* 1 使用Eclipse 工具建立一个普通Java控制台应用程序,
* 自定义一个类继承Counter 类,并根据理解定义在Counter
* 类中定义的抽象方法对父类的抽象方法进行实现,体会普通类
* 继承抽象类必需做什么? 不同子类在继承Counter抽象类并
* 实现抽象方法时的算法和什么有关.
*/ //定义一个抽象的父类Counter
public abstract class Counter {
//定义一个抽象方法addition
public abstract int addition(int num1, int num2); public Counter(){
System.out.println("调用Counter父类构造器");
}
}
/**
* 1 使用Eclipse 工具建立一个普通Java控制台应用程序,
* 自定义一个类继承Counter 类,并根据理解定义在Counter类中
* 定义的抽象方法对父类的抽象方法进行实现,体会普通类继承抽象
* 类必需做什么? 不同子类在继承Counter抽象类并实现抽象方法
* 时的算法和什么有关.
*/ public class Add extends Counter{ int num1 = 0;
int num2 = 0; //重写父类中的加法并实现加法
@Override
public int addition(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
return num1+num2; } public Add(){
System.out.println("调用Add子类构造器");
}
}

-----------------------------------------------分割线--------------------------------------------------------------

/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.test; import tool.abstracts.Construct;
import tool.abstracts.Tool;
import tool.abstracts.Traffic;
import tool.imp.Car;
import tool.imp.Hammer; public class Test {
public static void main(String[] args) {
//实例化顶级工具类对象,调用其中功能方法
Tool tool1 = new Traffic() {
@Override
public void constructTool() { }
};
tool1.trafficTool(); Tool tool2 = new Construct() {
@Override
public void trafficTool() { }
};
tool2.constructTool(); //实例化特殊工具类对象,调用其中功能方法
Traffic traffic = new Car();
traffic.trafficTool(); Construct construct = new Hammer();
construct.constructTool(); }
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.abstracts; //定义一个tool抽象类
public abstract class Tool {
//定义一个交通工具抽象方法
public abstract void trafficTool();
//定义一个建筑工具抽象方法
public abstract void constructTool();
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.abstracts; //定义一个交通工具抽象类继承自工具类
public abstract class Traffic extends Tool { public void trafficTool(){
System.out.println("我是所有交通工具的集合");
};
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.abstracts; //定义一个建筑工具抽象类继承自工具类
public abstract class Construct extends Tool { public void constructTool(){
System.out.println("我是所有建筑工具的集合");
};
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.adaptor; import tool.abstracts.Construct; //定义一个Construct的适配器
public class ConstructAdaptor extends Construct { //对交通工具方法进行一个重写和空实现
@Override
public void trafficTool() { }
//对建筑工具方法进行一个重写和空实现
@Override
public void constructTool() { }
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.adaptor; import tool.abstracts.Traffic; //定义一个Traffic的适配器
public class TrafficAdaptor extends Traffic { //对交通工具方法进行一个重写和空实现
@Override
public void trafficTool() {
System.out.println("我是所有交通工具的集合");
}
//对建筑工具方法进行一个重写和空实现
@Override
public void constructTool() { }
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.imp; import tool.adaptor.TrafficAdaptor; //定义一个普通类并具体实现交通工具方法
public class Car extends TrafficAdaptor {
@Override
public void trafficTool() {
System.out.println("我是交通工具汽车");
}
}
/**
*2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”,
* 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
* 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
* 类别的工具实体.
* 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
* 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
* 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
* 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
*
* 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
* 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
* 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
*/ package tool.imp; import tool.adaptor.ConstructAdaptor; //定义一个普通类并具体实现建筑工具方法
public class Hammer extends ConstructAdaptor {
@Override
public void constructTool(){
System.out.println("我是建筑工具锤子");
}
}

-----------------------------------分割线-----------------------------------

/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/ package test; import abstracts.Tool;
import imp.*; //定义一个主类Test
public class Test {
public static void main(String[] args) {
//实例化Person类
Person per = new Person();
//通过多态的方式,以父类的类型实例化各个子类
Tool car = new Car();
Tool plane = new Plane();
Tool print = new Printer();
Tool laptop = new Laptop(); //调用对应的子类去具体实现抽象方法
per.useTool(car);
per.useTool(plane);
per.useTool(print);
per.useTool(laptop);
}
}
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/ package abstracts; //定义一个抽象的工具类作为父类
public abstract class Tool {
//定义一个旅行的抽象方法
public abstract void travel(); //定义一个打印的抽象方法
public abstract void print(); //定义一个学习的抽象方法
public abstract void study();
}
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/
package adaptor; import abstracts.Tool; //定义一个适配器,继承工具类并提供3个方法的空实现
public class ToolAdaptor extends Tool {
@Override
public void travel() { } @Override
public void print() { } @Override
public void study() { }
}
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/
package imp; import adaptor.ToolAdaptor; //定义一个汽车类继承父类的适配器,重写并具体实现旅行的这个抽象方法
public class Car extends ToolAdaptor {
@Override
public void travel() {
System.out.println("使用汽车旅行");
}
}
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/
package imp; import adaptor.ToolAdaptor; //定义一个飞机类继承父类的适配器,重写并具体实现旅行的这个抽象方法
public class Plane extends ToolAdaptor {
@Override
public void travel(){
System.out.println("使用飞机旅行");
}
}
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/
package imp; import adaptor.ToolAdaptor; //定义一个笔记本电脑类继承父类的适配器,重写并具体实现学习的这个抽象方法
public class Laptop extends ToolAdaptor {
@Override
public void study(){
System.out.println("使用笔记本电脑学习Java");
}
}
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/
package imp; import adaptor.ToolAdaptor; //定义一个打印机类继承父类的适配器,重写并具体实现打印的这个抽象方法
public class Printer extends ToolAdaptor {
@Override
public void print() {
System.out.println("使用打印机打印文件");
} }
/**
* 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
* 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
* java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
* 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
* 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
* 完成此编程任务.
*/ package imp; import abstracts.Tool; //定义一个Person类
public class Person {
//定义一个使用工具的方法,接收tool抽象类的类型,并调用tool抽象类的三个抽象方法
public void useTool(Tool tool){
tool.travel();
tool.print();
tool.study();
}
}

Java抽象类、继承及多态和适配器的实现的更多相关文章

  1. Java的继承和多态

    看了博客园里面的一个文章,关于java的继承和多态: class A ...{ public String show(D obj)...{ return ("A and D"); ...

  2. 原来你是这样的JAVA[03]-继承、多态、抽象类

    一.继承 Java中的继承使用关键字extends ,跟C#的语法略有差别. 1.子类构造器 java会自动在子类的构造器中插入对父类构造器的调用,也就是说在子类可以访问父类之前已经完成了父类的初始化 ...

  3. Java面向对象㈡ -- 继承与多态

    Java的继承是通过extends和implement来实现的,Java不支持多继承,但是Java支持多层继承以及多实现(接口).Java继承有一个关键字super是用来指向父类.Java继承衍生出覆 ...

  4. [转]Java中继承、多态、重载和重写介绍

    什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承.多态.重载和重写. 继承(inheritance) 简单的说,继承就是在一个现有类型的基础上 ...

  5. [ Java学习基础 ] Java的继承与多态

    看到自己写的东西(4.22的随笔[ Java学习基础 ] Java构造函数)第一次达到阅读100+的成就还是挺欣慰的,感谢大家的支持!希望以后能继续和大家共同学习,共同努力,一起进步!共勉! ---- ...

  6. Java基础——继承和多态

    面向对象的编程允许从已经存在的类中定义新的类,这称为继承. 面向过程的范式重点在于方法的设计,而面向对象的范式将数据和方法结合在对象中.面向对象范式的软件设计着重于对象以及对象上的操作.面向对象的方法 ...

  7. java - day007 - 继承(2), 多态,面向对象,抽象类

    继承 新建子类对象是,先新建父类对象,并执行父类的构造方法, 默认执行父类的无参构造放方法 可以 手动调用父类的有参构造 super(参数 ) super super.xxx() 调用父类成员 一般重 ...

  8. java面向对象--继承与多态

    可以为一个变异单元中的每个类创建一个main方法,只有命令行所调用的那个类的main方法才会被调用,这样方便进行单元测试.继承时,一般将所有的数据成员都指定为private,将所有的方法指定为publ ...

  9. Java中继承与多态

    Java类的继承继承的语法结构:    [修饰符列表] class 子类名 extends 父类名{        类体;    }子类就是当前这个类,父类就是我们要复用的那个类java中只支持单继承 ...

随机推荐

  1. Mybatis学习之自定义持久层框架(七) 自定义持久层框架优化

    前言 接上文,这里只是出于强迫症,凭借着半年前的笔记来把之前没写完的文章写完,这里是最后一篇了. 前面自定义的持久层框架存在的问题 Dao层若使用实现类,会存在代码重复,整个操作的过程模版重复(加载配 ...

  2. 2020.12.14vj补题

    A. Lucky Ticket 题意:就是说4与7是幸运数字,用4和7组成的数字也是幸运数字,问所给数字是不是幸运数字 思路:直接敲 代码: 1 #include<iostream> 2 ...

  3. CSS3过渡应用

    小米图标转换 transition:需要过渡的属性 花费时间 (运动曲线 何时开始): Tips: 1.第二个属性值必须跟上单位(s) 2.谁要过渡给谁加 图标转换最终效果:当鼠标划过图标时,缓慢转换 ...

  4. 消息队列RabbitMQ(五):死信队列与延迟队列

    死信队列 引言 死信队列,英文缩写:DLX .Dead Letter Exchange(死信交换机),其实应该叫做死信交换机才更恰当. 当消息成为Dead message后,可以被重新发送到另一个交换 ...

  5. [bug] HMaster启动后几秒消失

    参考 https://blog.csdn.net/weixin_44896798/article/details/97800045 https://blog.csdn.net/liudi1993/ar ...

  6. Java中日志组件详解

    avalon-logkit Java中日志组件详解 lanhy 发布于 2020-9-1 11:35 224浏览 0收藏 作为开发人员,我相信您对日志记录工具并不陌生. Java还具有功能强大且功能强 ...

  7. Docker Swarm(十一)生产环境使用的一些建议

    一.Docker Swarm上的容器选择 并非所有服务都应该部署在Swarm集群内.数据库以及其他有状态服务就不适合部署在Swarm集群内. 理论上,你可以通过使用labels将容器部署到特定节点上, ...

  8. 2.1 CPU 上下文切换(上)

    cpu上下文与切换 进程在竞争 CPU 的时候并没有真正运行,为什么还会导致系统的负载升高呢?CPU 上下文切换就是罪魁祸首. 我们都知道,Linux 是一个多任务操作系统,它支持远大于 CPU 数量 ...

  9. STM32电路设计注意

    以后画STM32的电路板 VDDA一定要接 张JF说  VDDA是给内部的时钟电路供电的 还有一定要留 串口或者  下载调试口(串口) 或者显示器接口 输入输出设备最好都留着 这样才能方便调试

  10. 10.1 ifconfig:配置或显示网络接口信息

    ifconfig命令 用于配置网卡IP地址等网络参数或显示当前网络的接口状态,其类似于Windows下的ipconfig命令,这两个命令很容易混淆,读者需要区分一下.此外,ifconfig命令在配置网 ...