Java基础知识
来源:互联网 发布:网络营销策划案模板 编辑:程序博客网 时间:2024/05/17 01:59
一、
1、数据类型分类:
A:基本数据类型:4类8种
整数 占用字节数
byte 1 byte的范围是:-128到127。如果超过127,就是最小值-128.
short 2
int 4
long 8
浮点数
float 4
double 8
字符
char 2 可以存储一个汉字,Java语言里的字符占用两个字节,Java用的是Unicode编码。
布尔
boolean 1
B:引用数据类型:类,接口,数组。
2、数据类型转换(掌握)
(1)boolean类型不参与转换
(2)默认转换
A:从小到大
B:byte,short,char -- int -- long -- float(long,float的底层的存储结构不同,float在计算机中用四个字节存储,float表示的数据范围比long大)-- double
C:byte,short,char之间不相互转换,直接转成int类型参与运算。
(3)强制转换
A:从大到小
B:可能会有精度的损失,一般不建议这样使用。
C:格式:目标数据类型变量名 = (目标数据类型) (被转换的数据);
3、Java里面不支持全局变量。
二、
1、运算符:链接常量和变量,对常量和变量进行操作
运算:操作
整数相除只能得到整数,要想得到小数,把其中一个数转换为小数类型。
2、++、--
常量不可++、--
单独使用,放在操作数前面、后面,效果一样。
放在操作数的前面,先自增或自减,然后再参与运算。放在操作数后面,先参与运算,再自增或自减
3、扩展的赋值运算符其实隐含了一个强制类型转换。
面试题: short s=1;s=s+1;(没有转换类型,会损失精度)不同于short s=1;s+=1;s+=1等价于s=(s的数据类型)(s+1);
4、比较运算符:==,!=,>,>=,<,<=
无论操作简单还是复杂,结果返回boolean型值。
5、逻辑运算符
笔试题:& && | ||区别:
& 逻辑与,有false则false
&&有短路的作用,左边是false,右边不执行。
&和&&最终结果一样。
| 逻辑或,有true则true
||有短路的作用,左边是true,右边不执行。
!逻辑非,非false则true,非true则false。
^ 逻辑异或,相同为false,不同为true。
逻辑运算一般用于连接Boolean类型的表达式或者值。
6、位运算
& 有0则0
| 有1则1
^ 相同则0,不同则1。一个数据对另一个数据位异或两次,该数本身不变。
~ 按位取反。0变1,1变0(补码、反码、原码)
(1)因为是位运算,所以先转换成二进制。
<< 左移 左边最高位丢弃,空位补0 左移把左边的数据*2的移动次幂
>> 右移 最高位是0,左边补0;最高位是1,左边补1 右移把左边的数据/2的移动次幂
>>> 无符号右移 无论最高位是0还是1,左边补齐0
面试题: 两个整数变量的交换:
(1)使用第三方变量
(2)用位异或实现:
a=a^b;
b=a^b;(a^b^b=a)
a=a^b;(a^b^a=b)
(3)变量相加的做法
a=a+b;
b=a-b;
a=a-b;
(4) b=(a+b)-(a=b)
面试题:请用最有效率的方式写出计算2*8的结果
2<<3
7、三目运算符
格式:比较表达式?表达式1:表达式2
执行流程:根据表达式比较的计算返回一个true或者false,若true,表达式1作为结果,若false,表达式2作为结果。
8、如何实现键盘录入数据
A、导包:import java.util.Scanner;
B、创建键盘录入对象:Scanner sc = newScanner(System.in)
C、通过对象获取数据:int x = sc.nextInt();
D、String 是= sc.nextLine();获取字符串
四、流程控制语句
1、顺序结构:从上往下以此执行。
2、选择结构:按照不同的选择执行不同的代码。
if语句:比较表达式结果是boolean类型
if语句与三元运算符区别:三元简单。三元都可以用if实现,反之不成立。当if语句控制的操作是一个输出语句的时候就不能用三元实现,三元运算符操作完毕就应该有一个结果,而不是输出。。
switch语句:switch(表达式){case值1:语句体1;break;case值2:语句体2;break;…default:语句体n+1;(break;)程序最后一个break可以省略。}
case后只能是常量,不能是变量。Case后面不能出现相同值。Default可以省略,但是省略后就没有校验,他是对不正确情况作出提示。
面试题: switch表达式地方的值是有限定的。Byte、short、int、char;在JDK5以后可以是枚举;在JDK7以后可以是字符串。所以,byte、long(不可以)、String可以作为switch的表达式。
3、循环结构
for、while、(while(判断条件语句){循环体语句;控制条件语句;})
do…while循环格式:do{循环体语句;控制条件语句;}while(判断语句);先循环,后判断
区别:如果想在循环结束后继续使用控制条件的那个变量,使用while循环,否则使用for循环,因为变量及早的从内存中消失,可以提高内存使用效率。
如果不明确要做多少次循环,用while合适,如果明确,用for。
do…while循环至少执行一次循环体,而for,while循环先判断是否成立,然后决定是否执行循环体。
注意:死循环:A:控制条件语句控制的那个变量的问题,不要丢了。
B:两种最简单的死循环格式:while(true){}
for(;;){}
嵌套循环:外循环控制行数;内循环控制列数。
‘\t’tab键 ‘\r’回车 ‘\n’换行
4、跳转控制语句
goto在Java中是保留字不能使用,所以有
break:中断;switch语句中;循环语句中加入if判断时使用;效果:跳出单层循环;跳出多层循环;想要跳出多层循环,给循环起个名字(带标签的语句),break 循环名;
continue:继续;在循环语句中;
区别:break与continue区别:break是跳出循环,continue是跳出一次循环,进入下一次的执行。
return:返回;不是为了跳出循环体,常用结束一个方法。退出一个方法,跳转到上一个方法的调用。
五、方法和数组
1、方法:完成特定功能的代码块,在很多语言里面有函数的定义。
方法的执行特点:方法不调用不运行。
调用方法:在main方法中调用 方法名(参数);
有明确返回值调用:A、单独调用(没意义)
B、输出调用system.out.print(方法名(参数));
C、赋值调用int result=方法名(参数);
输出system.out.print(result);
方法注意事项:方法与方法是平级关系,不能嵌套定义。方法定义时候,参数用逗号隔开。方法调用时不用再传递数据类型。如果方法有明确返回值,一定要return带回一个值。
没有明确返回值:void类型方法定义调用:
A:单独调用(没问题,只有这一种调用)
B:输出调用(报错)
C:赋值调用(报错)
2、方法重载
方法功能相同,参数列表不同,Java允许起同样的方法名。根据传参的个数不同或者参数类型不同,虚拟机(JVM)自动识别。与返回值类型无关。
3、数组
存储多个变量的容器。变量类型一致。
4、Java中的内存分配
栈:存放的是局部变量(在方法定义中或方法声明上的变量)。栈内存的数据用完 就释放。
栈内存的两个引用指向同一个内存空间,无论是他们谁的操作,都是针对同一 个地方
堆:存放的是所有new出来的东西。
堆内存特点:A:每一个new出来的东西都有地址值。
B:每个变量都有默认值。
C:使用完就变成垃圾,不会立即回收,会在垃圾回收器空闲的 时候回收。
方法区:(面向对象部分详细讲解)
本地方法区(和系统相关)
寄存器(给CPU用)
5、数组的静态初始化
数据类型[] 数组名 = new 数据类型[] {元素1,元素2....}
简化:数据类型[] 数组名 = {元素1,元素2....};
动态数组初始化只给长度,系统给出默认值。
6、数组操作常见的问题
数组索引越界异常(原因:访问了不存在的索引);空指针异常(原因:数组已经不再指向堆内存,而你 还用数组名去访问元素);
数组遍历:for(int x =0;x<arr.length;x++){System.out.println(arr[x]);}
数组获取最值:找个参照物,遍历,大(小)的留下来,小(大)的离开。
数组逆序:A:for(int x=0;x<arr.length/2;x++)
{ int temp = arr[x];
arr[x] =arr[arr.length-1-x];
arr[arr.length-1-x= temp]; }
然后遍历数组;
B:for(intstart=0;end=x.length-1;stard<=end;start++;end--)
{ int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp; }
然后遍历数组;
数组查表法:(根据键盘录入,查找星期)
数组元素查找:(查找指定元素第一次在数组中出现的索引)
for(int x=0;x<arr.length;x++)
{ if(arr[x] == value)
{ index = x;
break; } }
注意:只要是判断,就可能是false,所以要有return -1;语句。
六、二维数组:元素是一维数组
1、二维数组
动态初始化:
数据类型[] [] 数组名 = new 数据类型[m][n] 列固定
数据类型[] [] 数组名 = new 数据类型[m][n] 列不固定
注意:int[] x,y[];x是一维数组;y是二维数组;二维数组第一个中括号里的值必须给出,第二个值可给可不给(内存没法分配)。
静态初始化:
数据类型[] [] 数组名 = new 数据类型[][]{{元素1,元素2,...},{元素1,元素2,...},...}
数据类型[] [] 数组名 = {{元素1,元素2,...},{元素1,元素2,...},...}
数组遍历:for(intx=o;x<arr.length;x++){
//外循环控制的是二维数组的长度,其实就是一维数组的个数;
for(int y=0;y<arr[x].length;y++){
//内循环控制的是一维数组的长度
system.out.println{arr[x][y]+””}}}
注意:Java中的参数传递问题:基本类型传递的是基本数据值,形式参数的改变对实际参数没有影响;引用类型传递的是地址值,形式参数的改变直接影响实际参数;
数据加密问题:把一组数(字符串)转换成数组形式:列如:12345转换成 arr[]={5,4,3,2,1}
int number=12345;
int index = 0;
while(number>0){
arr[index] = number%10;
index++;
number=number/10;}//转换之后数据已经倒序;
//把数组的元素拼接成一个字符串返回:
String s = “”;//定义一个空内容字符串;
for(int x=0;x<index;x++){
s+=arr[x];}
returns;
七、面向对象
1、面向对象思想:是基于面向过程的编程思想。
面向过程:强调的是每一个功能的步骤
面向对象:强调的是对象,然后由对象去调用功能。
面向对象特点:A:是一种更符合我们思想习惯的思想;
B:可以将复杂的事情简单化;
C:将我们从执行者变成了指挥者;
面向对象开发、设计、特征
A、开发:不断的创建对象,使用对象,指挥对象做事情。
B、设计:管理和维护对象之间的关系,
C、特征:封装、继承、多态。
类:是一组相关的属性和行为的集合。是一个抽象的概念。
对象:是该事物的具体表现形式。具体存在的个体。
变量:成员变量;局部变量区别:
A:在类中的位置不同
成员变量:在类中方法外
局部变量:在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存
C:生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
D:初始化值不同
成员变量:有默认初始化值
局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。
注意事项:
局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
形式参数问题:
基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数
如果你看到了一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象。
匿名对象:就是没有名字的对象。
匿名对象的应用场景:
A:调用方法,仅仅只调用一次的时候。
注意:调用多次的时候,不适合。
那么,这种匿名调用有什么好处吗?
有,匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
2、封装:
隐藏对象的属性和实现细节,对外提供公共访问方式。
A:好处:隐藏实现细节,提供公共的访问方式
提高代码的复用性
提高安全性
B:原则:将不需要对外提供的内容都隐藏起来
把属性隐藏,提供公共方法对其访问
关键字:private
可以修饰成员变量和成员方法。
被修饰的成员只能在本类中被访问。
封装和private常见应用:把成员变量用private修饰,提供对应的getXxx(),setXxx()方法;
This:
代表当前类的对象引用,方法被哪个类引用, 就代表当前类的一个对象。
解决局部变量隐藏成员变量
3、构造方法 construct
给对象的数据进行初始化
格式:A:方法名和类名相同
B:没有返回值类型,连void都没有
C:没有具体返回值
构造方法中可以有return语句,return;
在任何void类型的方法的最后都可以写上return;
注意事项:A:如果我们没有给出构造方法,系统将会自动提供一个无参构造方法
B:如果我们给出了构造方法(不管是有参无参),系统将不再提供默认 的无参构造。
给成员变量赋值有两种方式:
A:SetXxx()
B:带参构造方法
输出成员变量值的方法:
A:通过getXxx()分别获取然后拼接
B:通过调用show()方法搞定
4、类的组成:成员变量、构造方法、成员方法
A、调用无参返回值方法
S.show();
B、调用无参有返回值方法
String result =s.getString();
System.out.println(result);
C、调用带参无返回值方法
s.method(“”);
D、调用带参带返回值方法
String result2 =s.function(“hello”,”world”);
System.out.println(result2);
5、面向对象创建对象
Stusent s = new Student();
A、 把Student.class文件加载到内存
B、 在栈内存给s变量开辟一个空间
C、 在堆内存为学生对象申请一个空间
D、 给成员变量进行默认初始化
E、 给成员变量进行显示初始化
F、 通过构造方法给成员变量进行初始化
G、 初始化完毕,把堆内存的地址值赋值给栈内存的s变量
变量是用来描述这个类信息的时候,定义为成员变量。
变量的范围越小越好,因为能及时被回收。
关键字:static
静态修饰数据被所有对象共享。
特点:A、随着类的加载而加载。
B、优先于对象存在。
C、被类的所有对象共享。
D、可以通过类名调用。(也可以通过对象名调用)
静态修饰的内容一般我们称其为:与类相关的,类成员
静态方法中没有this
静态是随着类的加载而加载,this是随着对象的创建而存在,静态比对象先存在。
静态方法只能访问静态的成员变量和静态的成员方法。
静态变量和成员变量的区别
A:所属不同
静态变量:属于类,类变量
成员变量:属于对象,对象变量,实例变量
B:内存位置不同
静态变量:方法区的静态区
成员变量:堆内存
C:生命周期不同
静态变量:静态变量是随着类的加载而加载,随着类的消失而消失
成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失
D:调用不同
静态变量:可以通过对象名调用,也可以通过类名调用
成员变量:只能通过对象名调用
main方法是静态的
public:权限最大
static:不用创建对象调用
void:返回值给jvm没有意义
main:就是一个常见的名称。
String[]args:可以接收数据,提供程序的灵活性
格式:java MainDemo hello world java
java MainDemo 10 20 30
八、
1、代码块:用{}括起来的部分
2、分类:
局部代码块:局部位置,限定变量生命周期
构造代码块:在类中的成员位置,用大括号括起来,每次调用构造方法执行前,都会先执行构造代码块。
作用:可以把多个构造方法中的共同代码放一起
静态代码块:在类中的成员位置,用static修饰
作用:一般对类进行初始化
面试题:静态代码块,构造代码块,构造方法的执行顺序
静态代码块--构造代码块--构造方法
静态代码块:只执行一次
构造代码块每次调用构造方法都执行
3、继承
好处:提高代码复用性
提高代码的维护性
让类与类之间产生关系,是多态前提(也是继承弊端)
弊端:让类与类之间产生关系,类的耦合性增强。
要低耦合,高内聚。
打破了封装性
Java中继承的特点:
A:支持单继承,不支持多继承。
B:支持多层继承。
Java中继承注意事项
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
B:子类不能继承父类的构造方法,但可以通过super关键字去访问父类构造方法
C:不要为了部分功能而去继承。
4、This和super区别:
This代表本类对象的引用
Super代表父类存储空间的标志(可以理解为父类引用,可以操作父类成员变量)
A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
5、继承中成员变量的关系:
A:子类成员变量和父类成员变量名称不一样
B:子类成员变量和父类成员变量名称一样,采用就近原则。先在子类方法的局部 范围找,有就用;然后在子类成员范围找,有就用;在父类的局部范围找,有就使 用;如果都没有,就报错。
继承中构造方法关系:
A:子类的构造方法默认会去访问父类的无参构造方法
是为了子类访问父类数据的初始化
注意:每一个构造方法的第一条语句默认是super();
B:父类中如果没有无参构造方法
a:在父类中加一个无参构造
b:子类通过super去明确调用父类带参构造方法
子类中一定要有你一个访问了父类的构造方法,否则父类数据就没有 初始化。
c:子类通过this调用本身的其他构造,但是一定会有一个去访问了 父类的构造,让父类提供无参构造
注意:super()或者this()一定要放在第一行,如果不是第一行,就 可能对父类数据进行了多次初始化。
面试题:
A:一个静态代码块,构造代码块,构造方法的执行流程
静态代码块>构造代码块>构造方法
B:静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
C:子类初始化之前会进行父类的初始化
一个类的初始化过程:
成员变量初始化--默认初始化--显示初始化--构造方法初始化
子父类的初始化(分层初始化)
先进行父类初始化,然后进行子类初始化。
虽然子类的构造方法默认有一个super(),初始化的时候不是按照那个顺序 进行的。而是按照分层初始化进行的,它仅仅表示要先初始化父类数据,再初 始化子类数据。
6、继承中成员方法的关系:
A:子类中的方法和父类中的方法声明不一样
B:子类中的方法和父类中的方法声明一样
通过子类调用方法:
a:先找子类中有没有这个方法 ,有就使用
b:再看父类中有没有这个方法,有就使用
c:如果没有就报错
7、方法重写:子类中出现了和父类中方法声明一模一样的方法。(方法覆盖、复写)
如果方法名不同,就调用对应的方法
如果方法名相同,最终使用的是子类自己的。
方法重写应用:当子类需要父类的功能,又定义了子类特有的内容。
方法重载:本类中出现的方法名一样,参数列表不同的方法,与返回值无关。
方法重写注意事项:
父类中的私有方法不能被重写。因为父类私有方法子类无法继承。
子类重写父类方法时,访问权限不能更低。(最好一致)
父类静态方法,子类必须通过静态访问。
面试题:
1:方法重写和方法重载的区别?方法重载能改变返回值类型吗?
方法重写:在子类中,出现和父类中一模一样的方法声明的现象。
方法重载:同一个类中,出现的方法名相同,参数列表不同的现象。
方法重载能改变返回值类型,因为它和返回值类型无关。
2:this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用,通过这个东西可以访问父类的成员)
面试题:
A:一个类的初始化过程
成员变量的初始化
默认初始化
显示初始化
构造方法初始化
B:子父类的初始化(分层初始化)
先进行父类初始化,然后进行子类初始化。
九、
1、final关键字
可以修饰类、方法、变量。
特点:修饰类:该类不能被继承。
修饰方法:被final修饰的方法不能被子类重写。
修饰变量:该变量不能被重新赋值。
常量:A:字面值常量:
B:自定义常量:final
面试题:final修饰局部变量的问题:
局部变量是基本数据类型:可以修饰局部变量,值不可改变。
局部变量是引用数据类型:地址值不能变,该对象堆内存的值可以变。
2、final修饰变量的初始化时机:
A:被final修饰的变量只能赋值一次
B:在构造方法完毕前(静态的常量)
3、多态:某一个事物在不同时刻表现出来的不同状态。
多态的前提:
A:要有继承关系或者实现关系。
B:要有方法重写,如果没有也是可以的,只是没有意义。
C:要有父类引用指向子类对象 父 f = new 子()
4、多态中的成员访问特点:
A:成员变量
编译看左边,运行看左边。
B:构造方法
构造子类对象的时候,访问父类的构造方法,对父类的数据进行初始化。
C:成员方法
编译看左边,运行看右边。
D:静态方法
编译看左边,运行看左边。(静态和类相关算不上重写,所以,访问还是左边)
由于
成员方法存在方法重写,所以它运行看右边。
5、多态好处:
A:提高代码的维护性(继承保证)
B:提高代码的扩展性。(有多态保证)
6、多态弊端
父不能使用子类特有功能。
如果想用子类方法:A:创建子类对象调方法(太占内存)。
B:把父的引用强制转换为子的引用(向下转型)
对象间的转型问题:
向上转型:从子到父 父类引用指向子类对象:Fu f = newZi();
向下转型:从父到子 父类引用转为子类对象:Zi z =(Zi)f;
ClassCastException :类型转换异常。多态向下转型出现问题,不匹配。
多态的成员访问特点:
子类中有和父类中一样的方法叫重写;
子类中没有父类中出现过的方法,方法就被继承过来了。
7、抽象类:没有方法体的方法为抽象方法;类中有抽象方法,就是抽象类。
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰。
B:抽象类中不一定有抽象方法,但有抽象方法的类必须定义为抽象类
C:抽象类不能实例化,因为它不是具体的。抽象类有构造方法,但是不能实 例化。构造方法的作用是用于访问父类数据的初始化。
D:抽象的子类
a:如果不想重写抽象方法,孩子类是一个抽象类。
b:重写所有的抽象方法,这时候子类是一个具体的类。
抽象类的实例化是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();
抽象类的成员特点:
成员变量:既可以是变量,也可以是常量。
构造方法:有。用于子类访问父类数据初始化。
成员方法:既可以是抽象的,也可以是非抽象的。
抽象类的成员方法特性:
A:抽象方法 强制要求子类做的事情。
B:非抽象方法 子类继承的事情,提高代码复用性。
抽象类面试问题:
一个类如果没有抽象方法,可以定义为抽象类吗?可以。意义:不让创建对象。
Abstract不能和哪些关键字共存:
Private 冲突。不能被重写
Final 冲突。不能被重写。
Static 无意义。
8、接口:额外扩展的功能
接口特点:
A:接口用关键字interface表示 interface 接口名{}
B:实现接口用implements表示 class 类名 implements 接口名{}
C:接口按照多态的方式实例化。
D:接口的子类:
A:可以是抽象类,但意义不大。
B:可以是具体类。要重写接口中的所有抽象方法(推荐)
由此可见:
A:具体类多态(几乎没有)
B:抽象类多态(常用)
C:接口多态(最常用)
接口成员特点:
成员变量:接口中的变量默认(只能)是常量。并且是静态的。
有默认修饰符:publicstatic final
构造方法:没有构造方法。接口主要是扩展功能。
成员方法:默认修饰符public,只能是抽象方法。
所有的类都默认继承一个类:object,它是类层次结构的根类。
接口之间关系:
类与类:继承关系,只能单继承,可以多层继承。
类与接口:实现关系。可以单实现,也可以多实现,并且还可以在继承一个类 的同时实现多个接口。
接口与接口:继承关系。可以单继承,也可以多继承。
抽象类和接口的区别:
A:成员区别:
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别:
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
C:设计理念不同:
抽象类 被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系 的共性功能。
接口 被实现体现的是:”like a”的关系。接口中定义的是该继承体系的 扩展功能
十、
1、形参和返回值问题
形式参数:基本类型、引用类型
引用类型:类(匿名对象时讲过):需要的是该类的对象
抽象类:需要的是该抽象类的子类
接口:需要的是该接口的实现类对象
返回值类型:基本类型、引用类型
引用类型:类:返回的是该类的对象
抽象类:返回的是该抽象类的子类对象
接口:返回的是接口的实现类的对象
2、链式编程:对象调方法再调方法。每次调用完后,返回的是一个对象。
3、包:就是文件夹
作用:把相同类名放到不同文件夹中;对类进行分类管理。
定义:package 包名
面试题:package、import、class有没有顺序?
有,package>import>class
Package:只能有一个
Import:可以有多个
Class:可以有多个,建议用一个
- Java基础知识
- java基础知识
- java基础知识
- JAVA基础知识
- Java基础知识
- java基础知识
- java基础知识
- java基础知识
- java基础知识
- java基础知识
- java基础知识
- java基础知识
- JAVA基础知识
- Java 基础知识
- JAVA基础知识
- Java基础知识
- Java基础知识
- Java基础知识
- HYSBZ - 1257 余数之和sum (技巧&规律)
- Python抓取中文网页
- 输出重定向函数
- NodeJS实战
- 线程池的原理及实现
- Java基础知识
- Exynos4412 中断驱动开发(一)—— 中断基础及中断的注册过程
- 模拟迅雷下载程序 多线程
- (一)进程调度的相关算法
- ssh socket转发代理
- AE C# 图片标注背景透明
- 个人所得税计算器
- poj2352线段树
- 数据结构和算法笔记