JAVA知识点-适合自学、面试
1、Java的数据结构你用过那些?map与set的本质区别是什么
数据结构:是指相互之间存在一种或多种特定关系的数据元素的集合。
依据逻辑关系,数据结构分为:线性和非线性数据结构。
线性和非线性数据结构介绍引用:https://www.cnblogs.com/mr-wuxiansheng/p/8688946.html
2、Map与Set的本质区别是什么?
Set不能包含重复的元素,zui多有一个空值,继承自Collection接口,底层是Map实现机制。Map不能包含重复的键,每个键zui多对应一个映射的值,不能有空值键。两接口提供的方法不完全一样。
3、Java常见的数据结构有哪些?
Java常见的数据结构有Collection和Map,其中Collection接口下包括List和Set接口,其下又有多个实现类如List下有 ArrayList、LinkedList和Vector等实现类,Set下有HashSet、LinkedSet等实现类和SortedSet接 口,HashSet下有LinkedHashSet子类,SortedSet接口下有TreeSet实现类。Map接口下有HashMap(有 LinkedHashMap子类)、HashTable(有Properties子类)实现类和SortedMap接口(有TreeMap实现类)。
Java的数据结构主要有List、Set、Map、ArrayList、HashSet、HashMap、Properties等。
4、Java中的Annotation的工作原理是什么
一个 annotation类型被定义为runtime retention后,它才是在运行时可见,当class文件被装载时被保存在class文件中的annotation才会被虚拟机读取。
Annotation提供一种机制,将程序的元素如:类,方法,属性,参数,本地变量,包和元数据联系起来。这样编译器可以将元数据存储在Class文件中。这样虚拟机和其它对象可以根据这些元数据来决定如何使用这些程序元素或改变它们的行为。
5、分层架构中,Dao层的作用是什么?如果不要Dao层,能不能实现Dao层时的优点
Dao层又叫数据访问对象层, 封装数据库的底层操作细节如数据库的连接及对数据的CRUD等操作,它不但屏蔽了数据存储最终介质的不同,也屏蔽了具体实现技术的不同。一般在其上还会有 Service层来封装业务操作进行进一步的解耦。不用DAO层也能实现Dao层时的优点如自己封装一个类似Dao层功能的数据库操作模板类,可参考 Spring的DAO层思想。
6、JRE、JDK、JVM 及 JIT 之间有什么不同?
JRE 代表 Java 运行时(Java run-time),是运行 Java 引用所必须的。JDK 代表 Java 开发工具(Java development kit),是 Java 程序的开发工具,如 Java 编译器,它也包含 JRE。JVM 代表 Java 虚拟机(Java virtual machine),它的责任是运行 Java 应用。JIT 代表即时编译(Just In Time compilation),当代码执行的次数超过一定的阈值时,会将 Java 字节码转换为本地代码,如,主要的热点代码会被准换为本地代码,这样有利大幅度提高 Java 应用的性能。
7、3*0.1 == 0.3 将会返回什么?true 还是 false?
false,因为有些浮点数不能完全精确的表示出来。
8、32 位和 64 位的 JVM,int 类型变量的长度是多数?
32 位和 64 位的 JVM 中,int 类型变量的长度是相同的,都是 32 位或者 4 个字节。
9、我们能将 int 强制转换为 byte 类型的变量吗?如果该值大于 byte 类型的范围,将会出现什么现象?
是的,我们可以做强制转换,但是 Java 中 int 是 32 位的,而 byte 是 8 位的,所以,如果强制转化是,int 类型的高 24 位将会被丢弃,byte 类型的范围是从 -128 到 128。
10、JAVA 中堆和栈的区别,说下java 的内存机制
JVM 中堆和栈属于不同的内存区域,使用目的也不同。栈常用于保存方法帧和局部变量,而对象总是在堆上分配。栈通常都比堆小,也不会在多个线程之间共享,而堆被整个 JVM 的所有线程共享。
a.基本数据类型比变量和对象的引用都是在栈分配的
b.堆内存用来存放由new创建的对象和数组
c.类变量(static修饰的变量),程序在一加载的时候就在堆中为类变量分配内存,堆中的内存地址存放在栈中
d.实例变量:当你使用java关键字new的时候,系统在堆中开辟并不一定是连续的空间分配给变量,是根据零散的堆内存地址,通过哈希算法换算为一长串数字以表征这个变量在堆中的”物理位置”,实例变量的生命周期–当实例变量的引用丢失后,将被GC(垃圾回收器)列入可回收“名单”中,但并不是马上就释放堆中内存
e.局部变量: 由声明在某方法,或某代码段里(比如for循环),执行到它的时候在栈中开辟内存,当局部变量一但脱离作用域,内存立即释放
或者说heap和stack有什么区别。
java的内存分为两类,一类是栈内存,一类是堆内存。栈内存是指程序进入一个方法时,会为这个方法单独分配一块私属存储空间,用于存储这个方法内部的局部变量,当这个方法结束时,分配给这个方法的栈会释放,这个栈中的变量也将随之释放。
堆是与栈作用不同的内存,一般用于存放不放在当前方法栈中的那些数据,例如,使用new创建的对象都放在堆里,所以,它不会随方法的结束而消失。方法中的局部变量使用final修饰后,放在堆中,而不是栈中。
11、“a==b”和”a.equals(b)”有什么区别?
如果 a 和 b 都是对象,则 a==b 是比较两个对象的引用,只有当 a 和 b 指向的是堆中的同一个对象才会返回 true,而 a.equals(b) 是进行逻辑比较,所以通常需要重写该方法来提供逻辑一致性的比较。例如,String 类重写 equals() 方法,所以可以用于两个不同对象,但是是包含的字母相同的比较。
12、ArrayList 与 LinkedList 的不区别?
最明显的区别是 ArrrayList 底层的数据结构是数组,支持随机访问,而 LinkedList 的底层数据结构书链表,不支持随机访问。使用下标访问一个元素,ArrayList 的时间复杂度是 O(1),而 LinkedList 是 O(n)。
13、java 中怎么打印数组?
你可以使用 Arrays.toString() 和 Arrays.deepToString() 方法来打印数组。由于数组没有实现 toString() 方法,所以如果将数组传递给 System.out.println() 方法,将无法打印出数组的内容,但是 Arrays.toString() 可以打印每个元素。
三种方法:https://blog.csdn.net/chenkaibsw/article/details/78989459
14、extends与implements的区别
1. 在类的声明中,通过关键字extends来创建一个类的子类。
一个类通过关键字implements声明自己使用一个或者多个接口。
extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法;
implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
2. extends是继承父类,只要那个类不是声明为final或者那个类定义为abstract的就能继承
JAVA中不支持多重继承,但是可以用接口 来实现,这样就要用到implements,继承只能继承一个类,
但implements可以实现多个接口,用逗号分开就行了 比如 :
class A extends B implements C,D,E
接口实现的注意点:
a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。
b.接口中的方法都是抽象的。
c.多个无关的类可以实现同一个接口,一个类可以实现多个无关的接口。
与Extends的不同
extends, 可以实现父类,也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。这样的好处是:架构师定义好接口,让工程师实现就可以了。整个项目开发效率和开发成本大大降低。 implements,实现父类,子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数,也会被父类取代掉。
15、TreeMap 红黑树算法实现(key值从小到大排序Map)
介绍:https://blog.csdn.net/u014421556/article/details/52386035
16、Java 中的 LinkedList 是单向链表还是双向链表?
是双向链表,你可以检查 JDK 的源码。在 Eclipse,你可以使用快捷键 Ctrl + T,直接在编辑器中打开该类。
17、wait()和sleep()的区别
sleep来自Thread类,和wait来自Object类
调用sleep()方法的过程中,线程不会释放对象锁。而 调用 wait 方法线程会释放对象锁
sleep睡眠后不出让系统资源,wait让出系统资源其他线程可以占用CPU
sleep(milliseconds)需要指定一个睡眠时间,时间一到会自动唤醒
18、JAVA多态的实现原理
a.抽象的来讲,多态的意思就是同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)
b.实现的原理是动态绑定,程序调用的方法在运行期才动态绑定,追溯源码可以发现,JVM 通过参数的自动转型来找到合适的办法。
java中实现多态的机制是什么:靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的具体实例对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用变量的类型中定义的方法
19、
CAS(Compare And Swap) 无锁算法:
CAS是乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做。
20、finally块中的代码什么时候被执行?finally是不是一定会被执行?
try {}里有一个return语句,那么紧跟在这个try后的finally {}里的code会不会被执行,什么时候被执行,在return前还是后?
也许你的答案是在return之前,但往更细地说,我的答案是在return中间执行,请看下面程序代码的运行结果:
public class Test {public static void main(String[] args) {System.out.println(new Test().test());}static int test() {int x = 1;try {return x;} finally {++x;}}
}
---------执行结果 ---------
1
运行结果是1,为什么呢?主函数调用子函数并得到结果的过程,好比主函数准备一个空罐子,当子函数要返回结果时,先把结果放在罐子里,然后再将程序逻辑返回到主函数。所谓返回,就是子函数说,我不运行了,你主函数继续运行吧,这没什么结果可言,结果是在说这话之前放进罐子里的。
例2:
public class Test {public static void main(String[] args) {System.out.println(newTest().test());}int test() {try {return func1();} finally {return func2();}}int func1() {System.out.println("func1");return 1;}int func2() {System.out.println("func2");return 2;}
}
-----------执行结果-----------------
1 func1
2
3 func2
4
5 2
结论:finally中的代码比return 和break语句后执行
介绍:https://blog.csdn.net/dove_knowledge/article/details/71077512
21、interface 关键字实现接口定义
https://baike.baidu.com/item/interface/6070217?fr=aladdin
22、super的另外一个作用是调用父类的protected函数。只有通过"super"这个魔咒,我们才能操作父类的protected成员,别无它法。super()和this()均需放在构造方法内第一行。每个子类构造方法的第一条语句,都是隐含地调用super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。super()和this()类似,区别是,super()从子类中调用父类的构造方法,this()在同一类内调用其它方法。this()和super()都指的是对象,所以,均不可以在static环境中使用。包括:static变量,static方法,static语句块。
23、关于构造器的使用:https://blog.csdn.net/qq_36652405/article/details/79939297
24、
多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
多线程有两种实现方法,分别是继承Thread类与实现Runnable接口
同步的实现方面有两种,分别是synchronized,wait与notify
例子:https://www.cnblogs.com/nn369/p/8043303.html
线程的启动的两种方法: http://www.cnblogs.com/echo-cheng/p/6814909.html
可重入锁(ReentrantLock)实现公平锁与非公平锁:https://blog.csdn.net/yanyan19880509/article/details/52345422
25、在JAVA中如何跳出当前的多重嵌套循环?
在Java中,要想跳出多重循环,可以在外面的循环语句前定义一个标号,然后在里层循环体的代码中使用带有标号的break 语句,即可跳出外层循环。例如,
ok:
for(inti=0;i<10;i++) {
for(intj=0;j<10;j++) {
System.out.println(“i=”+ i + “,j=” + j);
if(j == 5) break ok;
}
}
另外,我个人通常并不使用标号这种方式,而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制,例如,要在二维数组中查找到某个数字。
int arr[][] = { { 1, 2, 3 }, { 4, 5, 6, 7 }, { 9 } };
boolean found = false;
for (int i = 0; i < arr.length && !found; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println("i=" + i + ",j=" + j);
if (arr[i][j] == 5) {
found = true;
break;
}
}
}
26、
StringBuffer的用法 :https://www.cnblogs.com/liu-chao-feng/p/5636063.html
Integer的用法 :http://www.cnblogs.com/zwxblog/p/7788573.html
27、
静态变量和实例变量的区别?
在语法定义上的区别:静态变量前要加static关键字,而实例变量前则不加。
在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。
例如,对于下面的程序,无论创建多少个实例对象,永远都只分配了一个staticVar变量,并且每创建一个实例对象,这个staticVar就会加1;但是,每创建一个实例对象,就会分配一个instanceVar,即可能分配多个instanceVar,并且每个instanceVar的值都只自加了1次。
public class VariantTest {
public static int staticVar = 0;
public int instanceVar = 0;
public VariantTest() {
staticVar++;
instanceVar++;
System.out.println("staticVar=" + staticVar + ",instanceVar=" + instanceVar);
}
}
28、是否可以从一个static方法内部发出对非static方法的调用?
不可以。因为非static方法是要与对象关联在一起的,必须创建一个对象后,才可以在该对象上进行方法调用,而static方法调用时不需要创建对象,可以直接调用。也就是说,当一个static方法被调用时,可能还没有创建任何实例对象,如果从一个static方法中发出对非static方法的调用,那个非static方法是关联到哪个对象上的呢?这个逻辑无法成立,例如:
public class exportKey {public static int staticVar = 0;public int instanceVar = 0;public exportKey() {staticVar++;instanceVar++;System.out.println("staticVar=" + staticVar + ",instanceVar=" + instanceVar);System.out.println(add(staticVar,instanceVar));}public static void main(String args[]) throws Exception {exportKey key1 = new exportKey();System.out.println(exportKey.staticVar);System.out.println(add(staticVar,staticVar));}public static int add(int a,int b){int sum = a + b;return sum;}
}
add方法如果去掉static会报编译错误;
29、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
Overload是重载的意思,Override是覆盖的意思,也就是重写。
重载Overload表示同一个类中可以有多个名称相同的方法,但这些方法的参数列表各不相同(即参数个数或类型不同)。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同,通过子类创建的实例对象调用这个方法时,将调用子类中的定义方法,这相当于把父类中定义的那个完全相同的方法给覆盖了,这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时,只能比父类抛出更少的异常,或者是抛出父类抛出的异常的子异常,因为子类可以解决父类的一些问题,不能比父类有更多的问题。子类方法的访问权限只能比父类的更大,不能更小。如果父类的方法是private类型,那么,子类则不存在覆盖的限制,相当于子类中增加了一个全新的方法。重写的意义:重写方法可以实现多态,用父类的引用来操纵子类对象,但是在实际运行中对象将运行其自己特有的方法。例如重写实现父类引用子类的方法:
public class Test {public static void main (String[] args) {Animal h = new Horse();h.eat(); }}class Animal {public void eat(){System.out.println ("Animal is eating.");}}class Horse extends Animal{public void eat(){System.out.println ("Horse is eating.");}public void buck(){}}
一个原则是:使用了什么引用,编译器就会只调用引用类所拥有的方法。如果调用子类特有的方法,如上例的h.buck(); 编译器会抱怨的(编译错误)。也就是说,编译器只看引用类型,而不是对象类型。
至于Overloaded的方法是否可以改变返回值的类型这个问题,要看你倒底想问什么呢?这个题目很模糊。如果几个Overloaded的方法的参数列表不一样,它们的返回者类型当然也可以不一样。但我估计你想问的问题是:如果两个方法的参数列表完全一样,是否可以让它们的返回值不同来实现重载Overload。这是不行的,我们可以用反证法来说明这个问题,因为我们有时候调用一个方法时也可以不定义返回结果变量,即不要关心其返回结果,例如,我们调用map.remove(key)方法时,虽然remove方法有返回值,但是我们通常都不会定义接收返回结果的变量,这时候假设该类中有两个名称和参数列表完全相同的方法,仅仅是返回类型不同,java就无法确定编程者倒底是想调用哪个方法了,因为它无法通过返回结果类型来判断。
override可以翻译为覆盖,从字面就可以知道,它是覆盖了一个方法并且对其重写,以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现,在接口中一般只是对方法进行了声明,而我们在实现时,就需要实现接口声明的所有方法。除了这个典型的用法以外,我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点:
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配,才能达到覆盖的效果;
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致;
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;
4、被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。
private修饰的变量,只能被该类中的方法访问,不能被外部的方法访问调用。如果外部类中的类想调用被private修饰的变量,就得给private修饰的变量添加set和get方法.在其他类中调用private修饰的变量时,直接调用private修饰的变量对应的get()方法就可以了。如果private修饰一个方法,那么这个方法就不能被外部类使用了
overload对我们来说可能比较熟悉,可以翻译为重载,它是指我们可以定义一些名称相同的方法,通过定义不同的输入参数来区分这些方法,然后再调用时,VM就会根据不同的参数样式,来选择合适的方法执行。在使用重载要注意以下的几点:
1、在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int,float),但是不能为fun(int,int));
2、不能通过访问权限、返回类型、抛出的异常进行重载;
3、方法的异常类型和数目不会对重载造成影响;
4、对于继承来说,如果某一方法在父类中是访问权限是priavte,那么就不能在子类对其进行重载,如果定义的话,也只是定义了一个新方法,而不会达到重载的效果。
package com.bit;class Animal {public void eat(){System.out.println ("Animal is eating."); }}class Horse extends Animal{public void eat(){System.out.println ("Horse is eating."); }public void eat(String food){System.out.println ("Horse is eating " + food);}}public class MainClass {public static void main (String[] args) {Animal a = new Animal();Horse h = new Horse();Animal ah = new Horse();a.eat();h.eat();h.eat("apple");ah.eat();//a.eat("apple");//ah.eat("apple");}}
a.eat(“apple”); 低级的错误,Animal类中没有eat(String food)方法。因此不能通过编译。
ah为多态实现,ah.eat(“apple”); 关键点就在这里。解决的方法还是那句老话,不能看对象类型,要看引用类型。Animal类中没有eat(String food)方法。因此不能通过编译。
静态方法可以和非静态方法一样被重载,静态方法是不能被覆盖(重写)的。
30、JAVA抽象类和抽象方法(abstract)说明:https://www.cnblogs.com/ibelieve618/p/6410910.html
31、Java提供了为类的成员变量赋初值的专门功能:构造方法(constructor)
构造方法是一种特殊的成员方法,它的特殊性反映在如下几个方面:
1.构造方法的名字必须与定义他的类名完全相同,没有返回类型,甚至连void也没有。
2.构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
3.每个类可以有零个或多个构造方法.
4.不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承。
5.构造方法在创建对象时自动执行,一般不能显式地直接调用. 构造方法可以被重载。没有参数的构造方法称为默认构造方法,与一般的方法一样,构造方法可以进行任何活动,但是经常将他设计为进行各种初始化活动,比如初始化对象的属性。
package com.bit;class RectConstructor{double length; double width; double high; double area(){ return length*width;} RectConstructor(double width,double length){//带参数的构造方法 this.length=length; this.width=width;} RectConstructor(double width,double length,double high){//带参数的构造方法 ,可以被重载,因为不能被继承,所以不能重写this.length=length; this.width=width;this.high=high;
}
}
public class MainClass{public static void main(String args[]){ RectConstructor rect1=new RectConstructor(10,20); RectConstructor rect2=new RectConstructor(3,6);double ar; ar=rect1.area();System.out.println("第一个长方形的面积是"+ar);ar=rect2.area(); System.out.println("第二个长方形的面积是"+ar);}
}
32、接口(Interface),是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。
接口定义的一般形式为:
[访问控制符]interface <接口名> {
类型标识符final 符号常量名n = 常数;
返回值类型 方法名([参数列表]);
…
}
接口的特点
1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
例如:
package com.bit;interface Person{void eat();void sleep();
}class Student implements Person{public void eat(){System.out.println("学生去食堂吃饭!");}public void sleep(){System.out.println("学生回寝室睡觉!");}
}class Teacher implements Person{public void eat(){System.out.println("教师去教工餐厅吃饭!");}public void sleep(){System.out.println("教师回学校公寓睡觉!");}
}class Parents implements Person{public void eat(){System.out.println("家长去招待所饭馆吃饭!");}public void sleep(){System.out.println("家长回招待所睡觉!");}
}public class PersonInterface{public static void main(String[] args){Person p=new Student();p.eat();p.sleep();p=new Teacher();p.eat();p.sleep();p=new Parents();p.eat();p.sleep();}
}
33、Java中private、protected、public和default的区别:
public:
具有最大的访问权限,可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况,也就是对象或类对外的一种接口的形式。
protected:
主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员,其他的不可以,它相当于传递给子类的一种继承的东西
default:
有时候也称为friendly,它是针对本包访问而设计的,任何处于本包下的类、接口、异常等,都可以相互访问,即使是父类没有用protected修饰的成员也可以。
private:
访问权限仅限于类的内部,是一种封装的体现,例如,大多数成员变量都是修饰符为private的,它们不希望被其他任何外部的类访问。
注意:java的访问控制是停留在编译层的,也就是它不会在.class文件中留下任何的痕迹,只在编译的时候进行访问控制的检查。其实,通过反射的手段,是可以访问任何包下任何类中的成员,例如,访问类的私有成员也是可能的。
34、深入理解Java中的final关键字:http://www.importnew.com/7553.html
35、abstract class和interface有什么区别?
含有abstract修饰符的class即为抽象类,abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class,abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现,所以,不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法,那么子类也必须定义为abstract类型。
接口(interface)可以说成是抽象类的一种特例,接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型,接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别:
1.抽象类可以有构造方法,接口中不能有构造方法。
2.抽象类中可以有普通成员变量,接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public,protected和(默认类型,虽然
eclipse下不报错,但应该也不行),但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法,接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。
7.一个类可以实现多个接口,但只能继承一个抽象类。
下面接着再说说两者在应用上的区别:
接口更多的是在系统架构设计方法发挥作用,主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用,可以实现代码的重用,例如,模板方法设计模式是抽象类的一个典型应用,假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常,那么就可以定义一个抽象的基类,让所有的Servlet都继承这个抽象基类,在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码,在各个子类中只是完成各自的业务逻辑代码,伪代码如下:
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public abstract class BaseServlet extends HttpServlet {public final void service(HttpServletRequest request, HttpServletResponse response)throws IOException, ServletException {// 记录访问日志// 进行权限判断}protected abstract void doService(HttpServletRequest request, HttpServletResponse response)throws IOException, ServletException;// 注意访问权限定义成protected,显得既专业,又严谨,因为它是专门给子类用的
}class MyServlet1 extends BaseServlet {protected void doService(HttpServletRequest request, HttpServletResponse response)throws IOException, ServletException {// 本Servlet只处理的具体业务逻辑代码}
}
父类方法中间的某段代码不确定,留给子类干,就用模板方法设计模式。
备注:这道题的思路是先从总体解释抽象类和接口的基本概念,然后再比较两者的语法细节,最后再说两者的应用区别。比较两者语法细节区别的条理是:先从一个类中的构造方法、普通成员变量和方法(包括抽象方法),静态变量和方法,继承性等6个方面逐一去比较回答,接着从第三者继承的角度的回答,特别是最后用了一个典型的例子来展现自己深厚的技术功底。
36、java之collection总结:http://www.cnblogs.com/taiwan/p/6954135.html
HashMap遍历常用方法:https://blog.csdn.net/qq_36719861/article/details/79503456
Map是java中的接口,Map.Entry是Map的一个内部接口。
Map提供了一些常用方法,如keySet()、entrySet()等方法。
keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map.Entry。
Map.Entry是Map声明的一个内部接口,此接口为泛型,定义为Entry<K,V>。它表示Map中的一个实体(一个key-value对)。接口中有getKey(),getValue方法。Map常用API:
clear() | 从 Map 中删除所有映射 |
remove(Object key) | 从 Map 中删除键和关联的值 |
put(Object key, Object value) | 将指定值与指定键相关联 |
putAll(Map t) | 将指定 Map 中的所有映射复制到此 map |
entrySet() | 返回 Map 中所包含映射的 Set 视图。Set 中的每个元素都是一个 Map.Entry 对象,可以使用 getKey() 和 getValue() 方法(还有一个 setValue() 方法)访问后者的键元素和值元素 |
keySet() | 返回 Map 中所包含键的 Set 视图。如果要删除 Set 中的元素还将会删除 Map 中相应的映射(键和值) |
values() | 返回 map 中所包含值的 Collection 视图。如果要删除 Collection 中的元素还将会删除 Map 中相应的映射(键和值) |
get(Object key) | 返回与指定键关联的值 |
containsKey(Object key) | 如果 Map 包含指定键的映射,则返回 true |
containsValue(Object value) | 如果此 Map 将一个或多个键映射到指定值,则返回 true |
isEmpty() | 如果 Map 不包含键-值映射,则返回 true |
size() | 返回 Map 中的键-值映射的数目 |
37、abstract的method是否可同时是static,是否可同时是native,是否可同时是synchronized?
abstract的method 不可以是static的,因为抽象的方法是要被子类实现的,而static与子类扯不上关系!
native方法表示该方法要用另外一种依赖平台的编程语言实现的,不存在着被子类实现的问题,所以,它也不能是抽象的,不能与abstract混用。例如,FileOutputSteam类要硬件打交道,底层的实现用的是操作系统相关的api实现,例如,在windows用c语言实现的,所以,查看jdk 的源代码,可以发现FileOutputStream的open方法的定义如下:
private native void open(String name)throws FileNotFoundException;
如果我们要用java调用别人写的c语言函数,我们是无法直接调用的,我们需要按照java的要求写一个c语言的函数,又我们的这个c语言函数去调用别人的c语言函数。由于我们的c语言函数是按java的要求来写的,我们这个c语言函数就可以与java对接上,java那边的对接方式就是定义出与我们这个c函数相对应的方法,java中对应的方法不需要写具体的代码,但需要在前面声明native。
关于synchronized与abstract合用的问题,我觉得也不行,因为在我几年的学习和开发中,从来没见到过这种情况,并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且,方法上的synchronized同步所使用的同步锁对象是this,而抽象方法上无法确定this是什么。
38、静态嵌套类(Static Nested Class)和内部类(Inner Class)讲解:
内部类就是在一个类的内部定义的类,内部类中不能定义静态成员(静态成员不是对象的特性,只是为了找一个容身之处,所以需要放到一个类中而已,这么一点小事,你还要把它放到类内部的一个类中,过分了啊!提供内部类,不是为让你干这种事情,无聊,不让你干。我想可能是既然静态成员类似c语言的全局变量,而内部类通常是用于创建内部对象用的,所以,把“全局变量”放在内部类中就是毫无意义的事情,既然是毫无意义的事情,就应该被禁止),内部类可以直接访问外部类中的成员变量,内部类可以定义在外部类的方法外面,也可以定义在外部类的方法体中
https://blog.csdn.net/machinecat0898/article/details/80071242
39、继承中的super.getclass().getName()
https://blog.csdn.net/f38327782/article/details/39669677
40、String s = "Hello";s = s + " world!";这两行代码执行后,原始的String对象中的内容到底变了没有?
没有。因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。在这段代码中,s原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。
通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。
同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:
public class Demo {private String s;...public Demo {s = "Initial Value";}...
}
而非:
s = new String("Initial Value");
后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实:对于字符串常量,如果内容相同,Java认为它们代表同一个String对象。而用关键字new调用构造器,总是会创建一个新的对象,无论内容是否相同。
至于为什么要把String类设计成不可变类,是它的用途决定的,并且String类是final类故不可以继承。。其实不只String,很多Java标准类库中的类都是不可变的。在开发一个系统的时候,我们有时候也需要设计不可变类,来传递一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本,即StringBuffer。
41、String 和StringBuffer的区别
JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地,你可以使用StringBuffers来动态构造字符数据。另外,String实现了equals方法,new String(“abc”).equals(newString(“abc”)的结果为true,而StringBuffer没有实现equals方法,所以,new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。
接着要举一个具体的例子来说明,我们要把1到100的所有数字拼起来,组成一个串。
1 StringBuffer sbf =new StringBuffer();
2 for(inti=0;i<100;i++)
3 {
4 sbf.append(i);
5 }
上面的代码效率很高,因为只创建了一个StringBuffer对象,而下面的代码效率很低,因为创建了101个对象。
1 String str = newString();
2 for(inti=0;i<100;i++)
3 {
4 str = str + i;
5 }
在讲两者区别时,应把循环的次数搞成10000,然后用endTime-beginTime来比较两者执行的时间差异,最后还要讲讲StringBuilder与StringBuffer的区别。
String覆盖了equals方法和hashCode方法,而StringBuffer没有覆盖equals方法和hashCode方法,所以,将StringBuffer对象存储进Java集合类中时会出现问题
42、如何把一段逗号分割的字符串转换成一个数组?
http://www.cnblogs.com/zhaideyou/p/5928386.html
43、深入理解Java中的字段与属性的区别: https://blog.csdn.net/chenchunlin526/article/details/71424844
44、final, finally, finalize的区别。
final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。
内部类要访问局部变量,局部变量必须定义成final类型,例如,一段代码……
finally是异常处理语句结构的一部分,表示总是执行。
finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。JVM不保证此方法总被调用
45、error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。 exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情况。
Java对异常进行了分类,不同类型的异常分别用不同的Java类表示,所有异常的根类为java.lang.Throwable,Throwable下面又派生了两个子类:Error和Exception,Error 表示应用程序本身无法克服和恢复的一种严重问题,程序只有死的份了,例如,说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题,其中又分为系统异常和普通异常,系统异常是软件本身缺陷所导致的问题,也就是软件开发人员考虑不周所导致的问题,软件使用者无法克服和恢复这种问题,但在这种问题下还可以让软件系统继续运行或者让软件死掉,例如,数组脚本越界(ArrayIndexOutOfBoundsException),空指针异常(NullPointerException)、类转换异常(ClassCastException);普通异常是运行环境的变化或异常所导致的问题,是用户能够克服的问题,例如,网络断线,硬盘空间不够,发生这样的异常后,程序不应该死掉。
java为系统异常和普通异常提供了不同的解决方案,编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理,所以普通异常也称为checked异常,而系统异常可以处理也可以不处理,所以,编译器不强制用try..catch处理或用throws声明,所以系统异常也称为unchecked异常。
提示答题者:就按照三个级别去思考:虚拟机必须宕机的错误,程序可以死掉也可以不死掉的错误,程序不应该死掉的错误;
46、最常见到的runtime exception 异常:
https://www.cnblogs.com/jack4738/p/6953242.html
47、同步和异步有何异同,在什么情况下分别使用他们?举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。
48、线程的基本概念、线程的基本状态以及状态之间的关系
一个程序中可以有多条执行线索同时执行,一个线程就是程序中的一条执行线索,每个线程上都关联有要执行的代码,即可以有多段程序代码同时运行,每个程序至少都有一个线程,即main方法执行的那个线程。如果只是一个cpu,它怎么能够同时执行多段程序呢?这是从宏观上来看的,cpu一会执行a线索,一会执行b线索,切换时间很快,给人的感觉是a,b在同时执行,好比大家在同一个办公室上网,只有一条链接到外部网线,其实,这条网线一会为a传数据,一会为b传数据,由于切换时间很短暂,所以,大家感觉都在同时上网。
状态:就绪,运行,synchronize阻塞,wait和sleep挂起,结束。wait必须在synchronized内部调用。
调用线程的start方法后线程进入就绪状态,线程调度系统将就绪状态的线程转为运行状态,遇到synchronized语句时,由运行状态转为阻塞,当synchronized获得锁后,由阻塞转为运行,在这种情况可以调用wait方法转为挂起状态,当线程关联的代码执行完后,线程变为结束状态。
49、子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次,请写出程序。
public class ThreadTest {private static boolean bShouldMain = false;public static void main(String[] args) {// new Thread() {// public void run() {// for (int i = 0; i < 50; i++) {// for (int j = 0; j < 10; j++) {// System.out.println("i=" + i + ",j=" + j);// }// }// }// }.start();// final String str = new String("");new Thread(new Runnable() {public void run() {for (int i = 0; i < 50; i++) {synchronized (ThreadTest.class) {if (bShouldMain) {try {ThreadTest.class.wait();} catch (InterruptedException e) {e.printStackTrace();}}for (int j = 0; j < 10; j++) {System.out.println(Thread.currentThread().getName() + "i=" + i + ",j=" + j);}bShouldMain = true;ThreadTest.class.notify();}}}}).start();for (int i = 0; i < 50; i++) {synchronized (ThreadTest.class) {if (!bShouldMain) {try {ThreadTest.class.wait();} catch (InterruptedException e) {e.printStackTrace();}}for (int j = 0; j < 5; j++) {System.out.println(Thread.currentThread().getName() + "i=" + i + ",j=" + j);}bShouldMain = false;ThreadTest.class.notify();}}}
}
下面使用jdk5中的并发库来实现的:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class ThreadTest {private static Lock lock = new ReentrantLock();private static Condition subThreadCondition = lock.newCondition();private static boolean bBhouldSubThread = false;public static void main(String[] args) {ExecutorService threadPool = Executors.newFixedThreadPool(3);threadPool.execute(new Runnable() {public void run() {for (int i = 0; i < 50; i++) {lock.lock();try {if (!bBhouldSubThread)subThreadCondition.await();for (int j = 0; j < 10; j++) {System.out.println(Thread.currentThread().getName() + ",j=" + j);}bBhouldSubThread = false;subThreadCondition.signal();} catch (Exception e) {} finally {lock.unlock();}}}});threadPool.shutdown();for (int i = 0; i < 50; i++) {lock.lock();try {if (bBhouldSubThread)subThreadCondition.await();for (int j = 0; j < 10; j++) {System.out.println(Thread.currentThread().getName() + ",j=" + j);}bBhouldSubThread = true;subThreadCondition.signal();} catch (Exception e) {} finally {lock.unlock();}}}
}
50、 java中有几种类型的流?JDK为每种类型的流提供了一些抽象类以供继承,请说出他们分别是哪些类?
字节流,字符流。字节流继承于InputStream OutputStream,字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流,主要是为了提高性能和使用方便。
字节流与字符流的区别
要把一片二进制数据数据逐一输出到某个设备中,或者从某个设备中逐一读取一片二进制数据,不管输入输出设备是什么,我们要用统一的方式来完成这些操作,用一种抽象的方式进行描述,这个抽象描述方式起名为IO流,对应的抽象类为OutputStream和InputStream,不同的实现类就代表不同的输入和输出设备,它们都是针对字节进行操作的。
在应用中,经常要完全是字符的一段文本输出去或读进来,用字节流可以吗?计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符,首先要得到其对应的字节,然后将字节写入到输出流。读取时,首先读到的是字节,可是我们要把它显示为字符,我们需要将字节转换成字符。由于这样的需求很广泛,人家专门提供了字符流的包装类。 底层设备永远只接受字节数据,有时候要写字符串到底层设备,需要将字符串转成字节再进行写入。字符流是字节流的包装,字符流则是直接接受字符串,它内部将串转成字节,再写入底层设备,这为我们向IO设别写入或读取字符串提供了一点点方便。字符向字节转换时,要注意编码的问题,因为字符串转成字节数组,其实是转成该字符的某种编码的字节形式,读取也是反之的道理。
往文件中写数据 之 PrintWriter用法简析 :https://www.cnblogs.com/xiaotiaosi/p/6394147.html
读文件,写文件,FileInputStream、FileOutputStream 类,详解:https://blog.csdn.net/u013836676/article/details/80493759
字符输入流:InputStreamReader 通常使用用缓冲区 BufferedReader实现功能由Reader类扩展而来,提供通用的缓冲方式文本读取,而且提供了很实用的readLine,读取一个文本行,从字符输入流中读取文本,缓冲各个字符,从而提供字符、数组和行的高效读取。
BufferedReader和BufferedWriter为默认带有缓冲的字符输出输入流,因为有缓冲区所以效率比没有缓冲区的高。
51、 什么是java序列化,如何实现java序列化?或者请解释Serializable接口的作用。
我们有时候将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象,例如,要将java对象存储到硬盘或者传送给网络上的其他计算机,这个过程我们可以自己写代码去把一个java对象变成某个格式的字节流再传输,但是,jre本身就提供了这种支持,我们可以调用OutputStream的writeObject方法来做,如果要让java 帮我们做,要被传输的对象必须实现serializable接口,这样,javac编译时就会进行特殊处理,编译的类才可以被writeObject方法操作,这就是所谓的序列化。需要被序列化的类必须实现Serializable接口,该接口是一个mini接口,其中没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的。
例如,在web开发中,如果对象被保存在了Session中,tomcat在重启时要把Session对象序列化到硬盘,这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi等远程调用,这就需要在网络上传输对象,被传输的对象就必须实现Serializable接口
Java 序列化Serializable详解(附详细例子):https://www.2cto.com/kf/201405/305380.html
52、 描述一下JVM加载class文件的原理机制?
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。
53、 HttpClient 4.3连接池参数配置及源码解读:http://www.bubuko.com/infodetail-1924266.html
post、get请求实例:https://www.jb51.net/article/124583.htm
54、线程池的应用: https://www.cnblogs.com/tuojunjie/p/6836597.html
55、 Java 的基础知识:数据结构(Map / List / Set等)、设计模式、算法、线程相关、IO/NIO、序列化等等。其次是高级特性:反射机制、并发与锁、JVM(GC策略 / 类加载机制 / 内存模型)
设计模式:https://www.jianshu.com/p/abc97e7539d6
Java设计模式之03_Builder(建造者模式):https://www.jianshu.com/p/0899376f9689
56、
JAVA知识点-适合自学、面试相关推荐
- java知识点总结(面试)
1.面向对象的特征有哪些方面? 答:面向对象的特征主要有以下几个方面: - 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面.抽象只关注对象有哪些属性和行为,并不关注 ...
- 那些让面试官直呼内行的Java知识点(二)
接上一篇 那些让面试官直呼内行的Java知识点(一) 其实此系列并非全是Java知识点,但都是作为Java语言开发者应该掌握的,好兄弟不骗好兄弟~ 1.mysql中char和varchar有什么区别? ...
- 那些让面试官直呼内行的Java知识点(一)
宝子们,你们要的面试题续集终于来啦~ 很多小伙伴反馈过,以前这篇 Java核心知识点精心整理 太长了,打开时页面都要卡一下 所以为了提升阅读体验,这次的面试题会分成若干小章节,每章只装十道题~ 开始吧 ...
- 适合大多数人Java学习路线(面试指南)
先来简单的介绍一下自己吧,博主本科双非 非科班,大三上学期开始学的Java,学了差不多学了六个月,最后也是成功拿到了字节的后端实习offer(已转正),写这篇文章主要是为了帮助住正打算学习Java又很 ...
- 【校招分享】Java非科班自学指南
作者:一星如月看多时 链接:[校招干货]Java非科班自学指南V1.0_招聘信息_牛客网 来源:牛客网 本文针对应届校招生,面向大厂面试学习,讲究打牢基础的同时追求速成,适合还有一年以上时间参加校招的 ...
- 数字海南Java开发工程师实习生面试全过程及反思
2020-12-7 数字海南Java开发工程师实习生面试全过程及试后反思 记录下人生第一次投递简历,正规实习求职面试,以及前前后后的准备与遇到的问题. 目录 2020-12-7 数字海南Java开发工 ...
- 网友:Java岗,自学一个月跳槽计算机视觉!附学习资源合集
笔者在脉脉上看到一条帖子:原来Java岗,自学一个月成功跳槽视觉算法岗. 这已经不是笔者第一次看到转行成功的程序员案例了,而大家的跳槽动机基本上都离不开,发展趋势.岗位高薪.职业兴趣. 计算机视觉 行 ...
- 给Java新手的一些建议——Java知识点归纳(Java基础部分)
写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会,主要是和一些java基础知识点相关的,所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们,希望可以给 ...
- 面试时,当你有权提问时,别客气,这是个逆转的好机会(内容摘自Java Web轻量级开发面试教程)...
前些天,我在博客园里写了篇文章,如何在面试中介绍自己的项目经验,收获了2千多个点击,这无疑鼓舞了我继续分享的热情,今天我来分享另外一个面试中的甚至可以帮助大家逆转的技巧,本文来是从 java web轻 ...
最新文章
- C# webform上传图片并生成缩略图
- Confluence 6 数据库表-系统信息(System information)
- mysql query cache优化
- 401 binary watch
- 车牌定位html5,车牌识别(一)——车牌定位(附详细代码及注释)
- Reeder 5.0.3 将RSS阅读体验发挥到极致
- php获取qq音乐的api类,利用QQ音乐api集成的php歌曲搜索
- excel同时冻结首行和首列怎么操作
- 深挖AI价值与温度,AETA地震预测AI算法大赛开启
- css代码 文字超出点点点
- 机器学习-西瓜书-模型评估
- 一次让人晕到吐血的接包经历
- 预测身高c需语言,预测身高问题。不知哪出问题了,算出乱码。求解!
- error: dst ref refs/heads/dev receives from more than one src.
- 【数量技术宅|量化投资策略系列分享】股指期货IF分钟波动率统计策略
- 【学习笔记】从零开始造一个汗液检测穿戴设备——01.葡萄糖电化学检测
- 六个方法是:指引、预示、安全区、分层、分支和打乱节奏
- tidb-cdc日志tables are not eligible to replicate
- 优酷弹幕穿人「渲染技术」揭秘
- Android 客户端与服务器端进行数据交互(一、登录服务器端)