关于c++的inline关键字,以下说法正确的是()
 A:使用inline关键字的函数会被编译器在调用处展开
 B:头文件中可以包含inline函数的声明
 C:可以在同一个项目的不同源文件内定义函数名相同但实现不同的inline函数
 D:定义在Class声明内的成员函数默认是inline函数
 E:优先使用Class声明内定义的inline函数
 F:优先使用Class实现的内inline函数的实现
 
解析：
 A 项错误，因为使用 inline 关键字的函数只是用户希望它成为内联函数，但编译器有权忽略这个请求，比如：若此函数体太大，则不会把它作为内联函数展开的。
 
B 项错误，头文件中不仅要包含 inline 函数的声明，而且必须包含定义，且在定义时必须加上 inline 。关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将 inline 放在函数声明前面不起任何作用。
 
C 项错误， inline 函数可以定义在源文件中，但多个源文件中的同名 inline 函数的实现必须相同。一般把 inline 函数的定义放在头文件中更加合适。
 
D 项正确，类内的成员函数，默认都是 inline 的。定义在类声明之中的成员函数将自动地成为内联函数。
 
EF 项错误， class 的成员函数都是 inline 的，加了关键字 inline也没有优先问题。

  刚刚使用 https://blog.csdn.net/qq_36923376/article/details/89709167 这个文章中的两个python文件测试了一下
 
pi.py
circle.py
 
试图说明下from 和import应该如何使用。
 首先circle.py想使用pi.py文件中的PI自变量，那么它有以下两种导入方式：
 
import python文件名
from python文件名 import python文件中具体的函数名或变量名
 
下面举例说明：
 
import pi
s = pi.PI*1*1
 
这个可以理解导入python文件中的全部函数和变量，若使用上述导入方式，那么在具体使用某个变量时应该以 pi.变量 的形式调用。
 
from pi import PI
s = PI*1*1
 
这个可以理解导入python文件中的PI这一个变量，若使用上述导入方式，那么在具体使用某个变量时可以直接使用变量名，也就是完全可以当做自己的变量了。

java面试题38 以下关于 abstract 关键字的说法，正确的是（）
 
A abstract 可以与final 并列修饰同一个类。
 
B abstract 类中不可以有private的成员。
 
C abstract 类中必须全部是abstract方法。
 
D abstract 方法必须在abstract类或接口中。
 
蒙蔽树上蒙蔽果，蒙蔽树下你和我。
 
 抽象一直以来都是人们所神往的艺术形式，这点从梵高，毕加索等艺术家的身上就可以看出。抽象所代表的是一种形式上的美感，颇有一种虚无缥缈只可意会不可言传的意味。但是JAVA中的抽象类与抽象方法相对而言就更加直接了，它给我的感觉更像是文章的副标题，本身不发挥什么作用，但是却可以从中展开许多功能。
 
  用关键字abstract修饰的类称为abstract类（抽象类），比如：
 
abstract classA{
 
}
 
用关键字abstract修饰的方法称为abstract方法（抽象方法），例如：
 
abstract int min （int x，int y）；
 
  对于abstract方法只允许声明，不允许实现（因为没有方法体）（毕竟叫抽象，当然不能实实在在的让你实现），并且不允许使用final和abstract同时修饰一个方法或者类，也不允许使用static修饰abstract方法。也就是说，abstract方法只能是实例方法，不能是类方法。
 
      既然abstract类和方法这么特殊，我们就必须对比一下它和普通类与方法之间的区别了：
 
1.abstract类中可以有abstract方法
 
 abstract类中可以有abstract方法，也可以有非abstract方法
 
 非abstract类中不可以有abstract方法
 
2.abstract类不能使用new运算符创建对象
 
但是如果一个非抽象类是抽象类的子类，这时候我们想要创建该对象呢，这时候它就必须要重写父类的抽象方法，并且给出方法体，这也就是说明了为什么不允许使用final和abstract同时修饰一个类或者方法的原因。
 
重点常考！：final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符，因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时期子类都覆盖不了这个方法，final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖，static是可以覆盖的，但是在调用时会调用编译时类型的方法，因为调用的是父类的方法，而父类的方法又是抽象的方法，又不能够调用，所以上的修饰符不能放在一起。
 
3.abstract类的子类
 
如果一个非abstract类是abstract类的子类，它必须重写父类的abstract方法，也就是去掉abstract方法的abstract修饰，并给出方法体。
 
如果一个abstract类是abstract类的子类，它可以重写父类的abstract方法，也可以继承父类的abstract方法。
 
下面举个例子：
 
abstract class GirlFriend{                                //抽象类，封装了两个行为标准

abstract void speak();

abstract void cooking();

}
 
class ChinaGirlFriend extends GirlFriend{

void speak(){

System.out.println("你好");

}

void cooking(){

System.out.println("水煮鱼");

}

}
 
class AmercanGirlFriend extends GirlFriend{

void speak(){

System.out.println("hello");

}

void cooking(){

System.out.println("roast beef");

}

}
 
class boy{

GirlFriend friend；

void setGirlFriend（GirlFriend f）{

friend=f；

}

void showGirlFriend（）{

friend.speaking();

friend.cooking();

}

}
 
public class text{

public static void main(String args[]){

GirlFriend girl =new ChineseGirlFriend();      //这里girl是上转型对象

Boy boy=new boy();

boy.setGirlFriend(girl);

boy.showGirlFriend();

girl=new AmericanGirlFriend();             //girl 是上转型对象

boy.setGirlFriend(girl);

boy.showGirlFriend();

}

}
 
1abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。
 
2最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写
 
3抽象类中可以有非抽象方法
 
4抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中
 
答案为D
 
我是歌谣，有什么不合理之处欢迎指出。来，一起刷题走起来
 
阅读目录（置顶)(长期更新计算机领域知识）
 
阅读目录（置顶)(长期更新计算机领域知识）
 
阅读目录（置顶)(长期科技领域知识）
 
歌谣带你看java面试题 

1、static关键字基本概念我们可以一句话来概括：方便在没有创建对象的情况下来进行调用。也就是说：被static关键字修饰的不需要创建对象去调用，直接根据类名就可以去访问。对于这个概念，下面根据static关键字的四个基本使用来描述。然后在下一部分再来去分析static的原理，希望你能认真读完。
 
2、static关键字修饰类java里面static一般用来修饰成员变量或函数。但有一种特殊用法是用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。
 
下面看看如何使用。
 
public class StaticTest {//static关键字修饰内部类public static class InnerClass{ InnerClass(){ System.out.println("====== 静态内部类======"); }
 public void InnerMethod() { System.out.println("===== 静态内部方法====="); } }
 public static void main(String[] args) { //直接通过StaticTest类名访问静态内部类InnerClass InnerClass inner=new StaticTest.InnerClass(); //静态内部类可以和普通类一样使用 inner.InnerMethod(); }}
 
如果没有用static修饰InterClass，则只能new 一个外部类实例。再通过外部实例创建内部类。
 
3、static关键字修饰方法修饰方法的时候，其实跟类一样，可以直接通过类名来进行调用：
 
public class StaticMethod { public static void test() {
 System.out.println("======= 静态方法===="); };
 public static void main(String[] args) { //方式一：直接通过类名 StaticMethod.test(); //方式二：
 StaticMethod fdd=new StaticMethod();
 fdd.test(); }}
 
4、static关键字修饰变量被static修饰的成员变量叫做静态变量，也叫做类变量，说明这个变量是属于这个类的，而不是属于是对象，没有被static修饰的成员变量叫做实例变量，说明这个变量是属于某个具体的对象的。我们同样可以使用上面的方式进行调用变量：
 
public class StaticVar { private static String name=“java的架构师技术栈”；
 public static void main(String[] args) {
 //直接通过类名 StaticVar.name; }}
 
5、static关键字修饰代码块静态代码块在类第一次被载入时执行，在这里主要是想验证一下，类初始化的顺序。父类静态变量父类静态代码块子类静态变量子类静态代码块父类普通变量父类普通代码块父类构造函数子类普通变量子类普通代码块子类构造函数代码验证一下：
 
首先我们定义一个父类
 public class Father{
 //父类静态代码块 static{ System.out.println(“Father static”); }
 //父类构造函数 public Father(){ System.out.println(“Father constructor”);
 }}
 然后定义一个子类public class Son extends Father{//静态代码块 static{ System.out.println(“Son static”); }
 //构造方法
 public Son(){
 System.out.println(“Son constructor”); }
 public static void main(String[] args) {
 new Son(); }}