目录
@、Java中数据类型有哪些?分别占用几个字节?String属于基本数据类型吗?
@、Java中的方法覆盖(Overwrite)和方法重载(Overload)的区别?
@、public,private,proteced,default四种权限的区别?
@、final、abstract、static、this、super的作用?
@、String & StringBuffer 和 StringBuilder 的区别:
@、JDK 和 JRE 区别?
- JDK:Java Development Kit 的简称,Java 开发工具包,提供了 Java 的开发环境和运行环境。
- JRE:Java Runtime Environment 的简称,Java 运行环境,为 Java 的运行提供了所需环境。
具体来说:JDK 其实包含了 JRE,同时还包含了编译 Java 源码的编译器 Javac,还包含了很多 Java 程序调试和分析的工具。
简单来说:如果你需要运行 Java 程序,只需安装 JRE 就可以了,如果你需要编写 Java 程序,需要安装 JDK。
包含关系:JDK包含JRE包含JVM。
@、Java中数据类型有哪些?分别占用几个字节?String属于基本数据类型吗?
java中数据类型分为两种 : 基本数据类型 和 引用数据类型(对象)
1):基本数据类型:整数(byte、short、int、long)、小数(float、double)、字符(char)、布尔(boolean)。
(不需要使用new创建,他们不会在堆上创建,而是直接在栈内存中存储,因此会更加高效。)
四种整数类型(byte、short、int、long):
- 整数数据类型默认是int。
- int占用4个字节 (整数的默认值)
- long类型在赋值时,需要在值后加入字母l(L)区分其是一个长整型
一种布尔类型(boolean):
- 只有true与false两个值。
- boolean占用1个字节。
一种字符类型(char):
两种浮点数类型(float、double):
- float类型在赋值时,需要在值后加入字母f(F)区分其是一个长整型
- double占用8个字节 (小数的默认值)
2):引用数据类型: 数组、类、接口。
级别从低到高为:byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换:从低级别到高级别,系统自动转的
强制类型转换:把一个高级别的数赋给一个别该数的级别低的变量
String 不属于基础类型,String 属于对象。
@、Java基本数据类型的包装类有哪些?为什么需要包装类?
在 java程序中所有的数据都需要当做对象来处理,针对8种基本数据类型提供了包装类:
int --> Integer
char --> Character
byte --> Byte
short --> Short
long --> Long
double --> Double
float --> Float
boolean --> Boolean
Java是一种面向对象语言,很多地方都需要使用对象而不是基本数据类型。
比如,在集合类中,我们是无法将int 、double等类型放进去的。因为集合的容器要求元素是Object类型。
@、包装类Integer和int的区别?
int是Java的一种基本数据类型,Integer是int的包装类,是引用数据类型。
默认值不同: int默认值为0,Integer的默认值为null。(推论:Integer既可以表示null又可以表示0)。
1. 默认值: int默认值为0,Integer的默认值为null。推论:Integer既可以表示null又可以表示0
2. Integer与int是不同的数据类型。(基本数据类型、/对象)。
3. 在集合框架中,只能存储对象类型,不能存储基本数据类型。
4. 方法中的基本类型变量存储在栈中,包装类型存放于堆中。
5. 包装类中提供了该类型相关的很多算法操作方法
如把十进制装换为2进制(toBinaryString),8进制(toOctalString),16进制(toHexString)。
1、Integer是int的包装类,int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用,而int变量不需要
3、Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针指向此对象;而int则是直接存储数据值
4、Integer的默认值是null,int的默认值是0
@、什么是自动拆装箱?
拆装箱:把基本数据类型转换成包装类的过程就是打包装,英文对应于boxing,中文翻译为装箱。
反之,把包装类转换成基本数据类型的过程就是拆包装,英文对应于unboxing,中文翻译为拆箱。
@、常用运算符有哪些?写一个常用的操作
运算符:用于操作操作数的运算符
算数:
+:可以进行数学+,还可以连接字符串(直接与字符串相连变为字符串,否则正常计算)
++/--:自增自减
单独使用 变量本身+1或-1
混合使用
++前置:先加1,在使用值
++后置:先使用值,再+1
/:(求商)两个整数相除,结果为商的整数部分
%:(求余)两个整数相除,结果为商的余数部分
private static void fun1() { int a =1; int b =1; int c =7; System.out.println(++a);//2 System.out.println(b++);//1 System.out.println(c/2);//3 System.out.println(c%2);//1 }
赋值: 将等号右边的值赋值给等号左边的变量
比较:比较相等与大小关系,结果为布尔值
逻辑: 参与计算的是两个布尔值,结果为布尔值
&&:并且 有假则假
||:或者 有真则真
^: 亦或 男女之间是真爱!
!:非 非真则假,非假则真
String mode = this.attributes.getString("mode"); if ((mode != null) && (mode.trim().equals("classical"))) { sb.append("<table width='100%' border='0' class='noBorder' align='center'><tr>"); } // 判断xx是否存在,当费减为1.0或者空白时,表示无xx if (fjbl == null||fjbl.equals("1.0")) { double money_nf = money_nianfei; }
三元运算符:
满足条件,结果1,不满足,结果2,条件是一个布尔值
(条件布尔表达式)?结果1:结果2
注意:三元运算符,一定是一个结果值,这个结果值必须被使用。
private static void fun2() { String ids0=" asd fghjkl "; ids0 = ids0 == null?"" : ids0.trim(); System.out.println(ids0);//asd fghjkl System.out.println((name==null)?0:name.hashCode())); }
@、引用类型使用?
1:导包:找到对应的类 类前边import 包名.类名; java.lang包下的类可以不导包,直接用
2:定义变量,创建对象,为变量赋值
引用类型 变量名 = new 引用类型();
3:调用方法
变量名.方法名();
Random:随机数类
所属包:java.util.Random
创建对象赋值变量:Random r = new Random();
调用方法:int randomNumber = r.nextInt(100);
Scanner:键盘录入类
所属包:java.util.Scanner
创建对象赋值变量:Scanner sc = new Scanner(System.in);
调用方法:int enterNumber = sc.nextInt();
@、equal和==、=什么区别?
=是赋值运算符
对于基本类型和引用类型 == 的作用效果是不同的:
- 基本类型:比较的是值是否相同;
- 引用类型:比较的是引用是否相同;
代码示例:
String x = "string"; String y = "string"; String z = new String("string"); System.out.println(x==y); // true System.out.println(x==z); // false System.out.println(x.equals(y)); // true System.out.println(x.equals(z)); // true 代码解读:因为 x 和 y 指向的是同一个引用,所以 == 也是 true,而 new String()方法则重写开辟了内存空间,所以 == 结果为 false,而 equals 比较的一直是值,所以结果都为 true。
== 对于基本类型来说是值比较(两个变量的值是否相等)。
==对于引用类型来说是比较是否是同一对象(两个变量在堆中存储的地址是否相同);
而 equals 默认情况下是引用比较,
public class Object { public boolean equals(Object obj) { return (this == obj); } } (默认的Object方法:)equals 本质上就是 ==
只是很多类重新了 equals 方法,比如 String、Integer 等把它变成了值比较,所以一般情况下 equals 比较的是值是否相等。
==比较的是2个对象的地址,而equals比较的是2个对象的内容。
显然,当equals为true时,==不一定为true;
@、重写equals为什么必须要重写hashCode?
因为默认的equals方法是Object的方法,比较的是内存地址;而默认的hashcode方法返回的是对象的内存地址转换成的一个整数。
相关类重写后的hashcode方法返回的新的哈希值与类的属性有关的。
假如只重写equals而不重写hashcode,那么Student类的hashcode方法就是Object默认的hashcode方法,由于默认的hashcode方法是根据对象的内存地址经哈希算法得来的,显然此时s1!=s2,故两者的hashcode不一定相等。
举个例子:
Student s1=new Student("小明",18);
Student s2=new Student("小明",18);
equals比较两对象内容是否相同,把两个内容相同的对象equals处理返回true,而hashcode方法根据对象的内存地址转换成一个数比较显然不相等。
原因:
1、默认的hashcode方法是根据对象的内存地址经哈希算法得来的;
2、Java规范的约定,在集合类中需要重写这两个方法;
关系:
equals()相等,hashcode()一定相等;
quals()不等,hashcode()可能相等;
如果不重写hashcode和equals方法的话,放入相同的key时(特殊情况下),就不知道取哪一个。
尽量用eclipse自动生成,尽量不要自己敲,很有可能出错。
@、说下Java堆、栈、内存的理解?
JVM内存的划分有五片:java分了5片内存。
1:寄存器。2:本地方法区。3:方法区。4:栈内存。5:堆内存。
栈:存储的都是局部变量 ( 函数中定义的变量,函数上的参数,语句中的变量 );
只要数据运算完成所在的区域结束,该数据就会被释放。
堆:用于存储数组和对象,也就是实体。啥是实体啊?就是用于封装多个数据的。
1:每一个实体都有内存首地址值。
2:堆内存中的变量都有默认初始化值。因为数据类型不同,值也不一样。
3:垃圾回收机制。
https://blog.csdn.net/jasonwang18/article/details/70578647
@、JVM加载class文件的原理机制?
Java的类加载器有三个,对应Java的三种类:
Bootstrap Loader // 负责加载系统类 (指的是内置类,像是String)
ExtClassLoader //负责加载扩展类(就是继承类和实现类)
AppClassLoader //负责加载应用类(程序员自定义的类)
Java采用了委托模型机制来协调工作:当类加载器需要加载类的时候,先请示其Parent(即上一层加载器)在其搜索路径载入,如果找不到,才在自己的搜索路径搜索该类。这样的顺序其实就是加载器层次上自顶而下的搜索,因为加载器必须保证基础类的加载。之所以是这种机制,还有一个安全上的考虑:如果某人将一个恶意的基础类加载到jvm,委托模型机制会搜索其父类加载器,显然是不可能找到的,自然就不会将该类加载进来。
我们可以通过这样的代码来获取类加载器:
ClassLoader loader = ClassName.class.getClassLoader(); ClassLoader ParentLoader = loader.getParent();
前面是对类加载器的简单介绍,它的原理机制非常简单,就是下面几个步骤:
1.装载:查找和导入class文件;
2.连接:
(1)检查:检查载入的class文件数据的正确性;
(2)准备:为类的静态变量分配存储空间;
(3)解析:将符号引用转换成直接引用(这一步是可选的)
3.初始化:初始化静态变量,静态代码块。
这样的过程在程序调用类的静态成员的时候开始执行,所以静态方法main()才会成为一般程序的入口方法。类的构造器也会引发该动作。
@、Java中class解析过程?
@、if&switch&while&for的使用?
当判断固定个数的值的时候,可以使用if,也可以使用switch。
switch工作原理:用小括号中的变量的值依次和case后面的值进行对比,和哪个case后面的值相同了,就执行哪个case后面的语句,如果没有相同的则执行default后面的语句;
char ch = 'A'; switch (ch) { case 'B': System.out.println("case one"); break; case 'A': System.out.println("case two"); break; }
while和for可以进行互换。
区别在于:如果需要定义变量控制循环次数。建议使用for。因为for循环完毕,变量在内存中释放。
for (int i = 0; i < 10; i++) { System.out.println("hi girl"); }
@、Java中的方法覆盖(Overwrite)和方法重载(Overload)的区别?
重载Overload:同一个类中可以有多个名称相同的方法,但这些方法的参数列表各不相同(即参数个数或类型不同)。
重写Override:发生在子类继承父的关系中,父类中的方法被子类继承.方法名,返回值类型,参数完全一样,但是方法体不一样.
表示子类中的方法可以与父类的某个方法的名称和参数完全相同,通过子类创建的实例对象调用这个方法时,将调用子类中的定义方法,这相当于把父类中定义的那个完全相同的方法给覆盖了,这也是面向对象编程的多态性的一种表现。
如何区分重载:当函数同名时,只看参数列表。和返回值类型没关系。
@、GC是什么? 为什么要用GC?好处有哪些?
(1)GC是垃圾收集的意思(Gabage['gɑːbɪdʒ] Collection)。
(2)内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的。Java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。要请求垃圾收集,可以调用下面的方法之一:System.gc() 或Runtime.getRuntime().gc() 。
(3)垃圾回收可以有效防止内存泄漏,有效的使用可用的内存。垃圾回收器通常作为一个低优先级的线程运行,不可预知的情况下对内存堆中已死亡的或者长时间没有使用的对象进行清除和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
回收机制:分代复制来及回收、标记来及回收、增量垃圾回收等方式
#Java语言没有提供释放已分配内存的显示操作方法。
@、谈谈面向对象的理解?
什么是面向对象及其特点:
面向对象:基于面向过程,找一个对象,帮帮你做事情。
1:将复杂的事情简单化。
2:面向对象将以前的过程中的执行者,变成了指挥者。
3:面向对象这种思想是符合现在人们思考习惯的一种思想。
java 的三大特点 也就是封装继承多态。
继承 可以看作是面向对象最显著的特征,继承是从已经有的类中派生出新的类 子类继承了父类的属性和行为,并且根据自己的需求扩展出新的行为,从而提高了代码的复用性, 多态 : 封装继承几乎都是为了多态做准备的 ,在执行期间判断对象的实际类型,根据实际类型调用响应的方法。
@、封装 继承 多态?
封装:就是把普通的对象进行封装,对象的属性设为private私有的,对外提供get、set方法,其他类只能通过get、set对对象属性值进行操作。
继承:是发生在两个类之间,一个类继承另一个类是说这个类属于另一个类,具有另一个类的所有属性和方法,同时它还可以有另一个类不具备的方法和属性。
多态:是建立在继承的基础上的,一个父类对象可以产生多个不同的子类对象,根据这些子类对象的不同可以具备不同的方法,也就是说表现出了不同的形态即多态。
父类中的私有成员变量,无法在子类中直接访问,可以通过从父类中继承得到的protected、public方法(如getter、setter方法)来访问。
https://blog.csdn.net/evilcry2012/article/details/52230622
@、什么是内存泄露、内存溢出?
内存泄漏:就是忘记释放使用完毕的内存,让下次使用有一定风险。
- 内存泄露是指程序中间动态分配了内存,但在程序结束时没有释放这部分内存,从而造成那部分内存不可用的情况,重启计算机可以解决,但也有可能再次发生内存泄露,内存泄露和硬件没有关系,它是由软件设计缺陷引起的。
- 比如:缓存的应用,如果不设置上限的话,缓存的容量可能会一直增长。
- 内存泄漏可以分为4类:
- 1. 常发性内存泄漏:发生内存泄漏的代码会被多次执行到。
- 2. 偶发性内存泄漏:发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。
- 3. 一次性内存泄漏:发生内存泄漏的代码只会被执行一次,或者由于算法上的缺陷,导致总会有一块仅且一块内存发生泄漏。
- 4. 隐式内存泄漏:。程序在运行过程中不停的分配内存,但是直到结束的时候才释放内存。(几周甚至几个月,不及时释放内存也可能导致最终耗尽系统的所有内存。)
内存溢出:对于整个应用程序来说,JVM内存空间已经没有多余的空间分配给新的对象,造成内存数据溢出。
@、初始化和实例化区别?
初始化:
就是给已有的实例或者变量进行赋予初始值。
实例化指将一个类实例化成一个对象 。
初始化:int i=0; 实例化:class c = new class();
一个对象实例化过程:
Person p = new Person();
1,JVM会读取指定的路径下的Person.class文件,并加载进内存,
并会先加载Person的父类(如果有直接的父类的情况下)。
2,在堆内存中的开辟空间,分配地址。
3,并在对象空间中,对对象中的属性进行默认初始化。
4,调用对应的构造函数进行初始化。
5,在构造函数中,第一行会先到调用父类中构造函数进行初始化。
6,父类初始化完毕后,在对子类的属性进行显示初始化。
7,在进行子类构造函数的特定初始化。
8,初始化完毕后,将地址值赋值给引用变量.
@、多态的4种实现方式?
接口实现接口, 类实现类,重载和重写。
@、关键词instanceof用法?
双目运算符。当左边的对象是右边的类的实例或子类的实例。返回true,否则false.
关键字用法:A instanceof B ,返回值为boolean类型,用来判断A是否是B的实例对象或者B子类的实例对象。
如果是则返回true,如果不是,或者A是 null,返回false。
如:
Person p = new Person() ;
// Man m = new Man() ;
//Man是Person的子类
Animal a = new Animal() ;
m instanceof Man
//返回true
m instanceof Animal
//返回false
m instanceof Person
//返回true
@、修饰符有哪些?
权限修饰符:private、 default、protected、public
状态修饰符:static、final
抽象修饰符:abstract
@、public,private,proteced,default四种权限的区别?
public |
protected |
default |
private |
|
本类 |
Y |
Y |
Y |
Y |
同一包---子类、无关类 |
Y |
Y |
Y |
N |
不同包---子类 |
Y |
Y |
N |
N |
不同包--无关类 |
Y |
N |
N |
N |
@、final、abstract、static、this、super的作用?
final(最终):用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。内部类要访问局部变量,局部变量必须定义成final类型。
finally是异常处理语句结构的一部分,表示总是执行。
finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提高垃圾收集时的其他资源回收,例如关闭文件等。JVM不保证此方法总被调用。
static:是一个修饰符,用于修饰成员(成员变量和成员函数),被static修饰的成员属于类,不属于单个这个类的某个对象。
特点:
1、被静态修饰的成员变量,其值属于类,被所有成员共享。
2、被静态修饰的成员,可以直接被类名所调用。类名.静态方式。(也就是说,静态的成员多了一种调用方式。)
3、用static修饰的代码块表示静态代码块,当Java虚拟机(JVM)加载类时,就会执行该代码块(用处非常大)。(而且优先于对象存在)
abstract:
抽象类的特点:
1:抽象方法只能定义在抽象类中,抽象类和抽象方法必须由abstract关键字修饰(可以描述类和方法,不可以描述变量)。
2:抽象方法只定义方法声明,并不定义方法实现。
3:抽象类不可以被创建对象(实例化)。
4:只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后,该子类才可以实例化。否则,该子类还是一个抽象类。
抽象类的细节:
1:抽象类中是否有构造函数?有,用于给子类对象进行初始化。
2:抽象类中是否可以定义非抽象方法?
可以。其实,抽象类和一般类没有太大的区别,都是在描述事物,只不过抽象类在描述事物时,有些功能不具体。所以抽象类和一般类在定义上,都是需要定义属性和行为的。只不过,比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
3:抽象关键字abstract和哪些不可以共存?final , private , static
4:抽象类中可不可以不定义抽象方法?可以。抽象方法目的仅仅为了不让该类创建对象。
This:代表是本类类型的对象引用。
Super:代表是子类所属的父类中的内存空间引用。
super()和this()是否可以同时出现在构造函数中。
两个语句只能有一个定义在第一行,所以只能出现其中一个。
super()或者this():为什么一定要定义在第一行?
因为super()或者this()都是调用构造函数,构造函数用于初始化,所以初始化的动作要先完成。
局部变量:被final修饰,声明之后,可以赋值一次。
成员变量:被final修饰,声明时,就必须赋值,就是常量了。常量名字母要求全部大写。
@、final finally finalize区别?
@、关键字:enum,使用方法?
@、抽象类和接口的区别?
抽象类:含有abstract修饰的类即为抽象类,抽象类不能创建实例对象。含有abstract方法的类必须定义为抽象类,抽象类中的方法不必是抽象的。(抽象类中定义抽象方法必须在具体子类中实现,所以,不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法,那么子类也必须定义为abstract类型)。
接口:可以说成是抽象类的一种特例,接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型,接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别:
1. 抽象类可以有构造方法,接口中不能有。
2. 抽象类中可以有普通成员变量,接口中没有普通成员变量
3. 抽象类中可以包含静态方法,接口中不能包含静态方法
4. 一个类可以实现多个接口,但只能继承一个抽象类。
5. 抽象类中可以定义非抽象方法,子类可以直接继承使用;接口中必须都是抽象方法,需要子类去实现。
6. 抽象类中的抽象方法的访问类型可以使public、protected和默认类型,但接口中的抽象方法只能是public类型的,并且默认修饰即为public abstract类型。
7. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。
@、构造方法是什么?有什么用?
@、API简介
--- java.util.Math: 用于数学运算的工具类,属性和行为都是静态的。该类是final不允许继承。
static double ceil(double a) ; //返回大于指定数值的最小整数 static double floor(double a) ; //返回小于指定数值的最大整数 static long round(double a) ; //四舍五入成整数 static double pow(double a, double b) ; //a的b次幂 static double random(); //返回0~1的伪随机数 public static void main(String[] args) { Random r = new Random(); for(int x=0; x<10; x++) { //double d = Math.floor(Math.random()*10+1); //int d = (int)(Math.random()*10+1); int d = r.nextInt(10)+1; System.out.println(d);
API--- java.util.Date:日期类,月份从0-11;
API--- java.lang.Runtime: 类中没有构造方法,不能创建对象。
但是有非静态方法。说明该类中应该定义好了对象,并可以通过一个static方法获取这个对象。用这个对象来调用非静态方法。这个方法就是 static Runtime getRuntime();
这个Runtime其实使用单例设计模式进行设计。
class RuntimeDemo {
public static void main(String[] args) throws Exception {
Runtime r = Runtime.getRuntime();
Process p = r.exec("notepad.exe SystemDemo.java"); //运行指定的程序
Thread.sleep(4000);
p.destroy(); //杀掉进程
}
}
@、String & StringBuffer 和 StringBuilder 的区别:
1、String字符串常量,StringBuffer字符串变量,StringBuilder字符串变量
(String是“字符创常量”,也就是不可改变的对象。
是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.
String s = "abcd"; s = s+1; System.out.print(s);// result : abcd1)
string是可继承类吗 ?
因为Sting是这样定义的:public final class String extends Object,里边有final关键字,所以不能被 继承。
2、StringBuilder与 StringBuffer
StringBuilder: 效率高,线程不安全(单线程操作,使用StringBuilder)。
StringBuffer:线程安全的(多线程操作,使用StringBuffer 安全)
3、 对于三者使用的总结:
1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
总结: 如果在程序中需要对字符串进行频繁的修改连接操作的话.使用StringBuffer性能会更高
在java中有3个类来负责字符的操作。
1.Character 是进行单个字符操作的,
2.String 对一串字符进行操作。不可变类。
3.StringBuffer 也是对一串字符进行操作,但是可变类。
@、IO流有哪些?区别是什么?常用操作?
流的操作只有两种:读和写。
字节流:InputStream OutputStream
字符流:Reader Writer
IO流操作:
@、close()和flush()的区别?
flush():将缓冲区的数据刷到目的地中后,流可以使用。
close():将缓冲区的数据刷到目的地中后,流就关闭了,该方法主要用于结束调用的底层资源。这个动作一定做。
@、介绍下递归?
递归:就是函数自身调用自身。
什么时候用递归呢?
当一个功能被重复使用,而每一次使用该功能时的参数不确定,都由上次的功能元素结果来确定。
简单说:功能内部又用到该功能,但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。
递归的注意事项:
1:一定要定义递归的条件。
2:递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
其实递归就是在栈内存中不断的加载同一个函数。
public class jiecheng { public static void main(String[] args) { System.out.println("阶乘的结果:"+jiecheng.multiply(10)); } public static int multiply(int n){ if(n==1){ return n; } else{ return n*multiply(n-1); } } }
@、正则表达式是什么?常见应用?
其实是用来操作字符串的一些规则。
好处:正则的出现,对字符串的复杂操作变得更为简单。
特点:将对字符串操作的代码用一些符号来表示。只要使用了指定符号,就可以调用底层的代码对字符串进行操作。符号的出现,简化了代码的书写。
弊端:符号的出现虽然简化了书写,但是却降低了阅读性。
其实更多是用正则解决字符串操作的问题。
组:用小括号标示,每定义一个小括号,就是一个组,而且有自动编号,从1开始。
只要使用组,对应的数字就是使用该组的内容。别忘了,数组要加\\。
(aaa(wwww(ccc))(eee))技巧,从左括号开始数即可。有几个左括号就是几组。
常见操作:
1,匹配:其实用的就是String类中的matches方法。
String reg = "[1-9][0-9]{4,14}";
boolean b = qq.matches(reg);//将正则和字符串关联对字符串进行匹配。
2,切割:其实用的就是String类中的split方法。
3,替换:其实用的就是String类中的replaceAll();
4,获取:
1),先要将正则表达式编译成正则对象。使用的是Pattern中静态方法 compile(regex);
2),通过Pattern对象获取Matcher对象。
Pattern用于描述正则表达式,可以对正则表达式进行解析。
而将规则操作字符串,需要从新封装到匹配器对象Matcher中。
然后使用Matcher对象的方法来操作字符串。
如何获取匹配器对象呢?
通过Pattern对象中的matcher方法。该方法可以正则规则和字符串想关联。并返回匹配器对象。
3),使用Matcher对象中的方法即可对字符串进行各种正则操作。
@、实例化&序列化?
序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题(如果不进行序列化可能会存在数据乱序的问题)。
要实现序列化,需要让一个类实现Serializable接口,该接口是一个标识性接口,标注该类对象是可被序列化的,然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出(即保存其状态);如果需要反序列化则可以用一个输入流建立对象输入流,然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外,还能够用于对象的深度克隆。
@、什么是序列化?为什么要使用?
对象的序列化:目的:将一个具体的对象进行持久化,写入到硬盘上。
注意:静态数据不能被序列化,因为静态数据不在堆内存中,是存储在静态方法区中。
如何将非静态的数据不进行序列化?用transient 关键字修饰此变量即可。
序列化:就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现:将需要被序列化的类实现Serializable接口,然后使用一个输出流(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象,接着使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流ObjectInputStream。