Core Java 的知识点总结
1.jdk ,jre,jvm的区别:jdk:Java 开发工具包（JRE+编译工具） jre:Java 运行时环境（JVM+类库）jvm:Java 虚拟机2.环境变量的解释:目的：在任意路径下能够直接执行相关命令。原理：在命令行中执行某个命令时，首先在当前路径下查找，如果找不到则到PATH 配置的各个路径下查找。3.声明数组的三种方式int[] nums = new int[5]; //初始化为默
1.jdk ,jre,jvm的区别:
jdk:Java 开发工具包（JRE+编译工具）
jre:Java 运行时环境（JVM+类库）
jvm:Java 虚拟机
2.环境变量的解释:
目的：在任意路径下能够直接执行相关命令。
原理：在命令行中执行某个命令时，首先在当前路径下查找，如果找不到则到PATH 配置的各个路径下查找。
3.声明数组的三种方式
int[] nums = new int[5]; //初始化为默认值
int[] nums = {1,2,3,4,5}; //初始化为{}中指定的值，静态初始化
int[] nums = new int[] {1,2,3,4,5};//初始化为{}中指定的值，静态初始化
4.java标识符的命名规则
（1）以字母、数字、_或$组成
（2）不能以数字开头
（3）不能使用 java 的关键字和保留字
(4) 标识符的长度没有限制
(5) Java 是大小写敏感的，所有标识符区分大小写
5.java的注释有几种
单行注释、多行注释、文档注释
6. java注释的应用场景
一般类、方法、非私有变量 用/** */，这样他人开发用到jar中的该类时，调用它的人看到，生产doc文档时也能被生产出来，内部私有变量、方法里的语句注释用// 自己知道就行
注释格式：
1、单行(single-line)注释：“//……”
2、块(block)注释：“/*……*/”
3、文档注释：“/**……*/”
4、javadoc 注释标签语法
@author 对类的说明标明开发该类模块的作者
@version 对类的说明标明该类模块的版本
@see 对类、属性、方法的说明参考转向，也就是相关主题
@param 对方法的说明对方法中某参数的说明
@return 对方法的说明对方法返回值的说明
@exception 对方法的说明对方法可能抛出的异常进行说明
Java SE5内置了三种标准注解：
@Override，表示当前的方法定义将覆盖超类中的方法。
@Deprecated，使用了注解为它的元素编译器将发出警告，因为注解@Deprecated是不赞成使用的代码，被弃用的代码。
@SuppressWarnings，关闭不当编译器警告信息。
7.java的关键字有多少种 ? 50种
8.java的保留字有哪些? Java 保留了 const 和 goto 关键字
9.java的数据类型分为哪些?
基本数据类型 { 数值型{ 整数类型(byte,short,int,long) 浮点类型(float,double) } 字符型(char) 布尔型(boolean)}
引用数据类型{类(class) 接口(interface) 数组 }
10.说出5个String的常用方法?
(1)替换字符串 replace();
(2)分割字符串 split("regex");
(3)equals 字符串比较
(4)length() 获取长度、
(5) getBytes() 将一个字符串转换成字节数组
(6)toCharArray()将一个字符串转换成字符数组
(7)equalsIgnoreCase(String) 忽略大小写的比较两个字符串的内容是否一模一样
(8)contains(String)判断一个字符串里面是否包含指定的内容
(9)startsWith(String)判断一个字符串是否以指定的内容开头
(10)endsWith(String)判断一个字符串是否以指定的内容结尾
(11)toUpperCase()将一个字符串全部转换成大写
(12)toLowerCase() 将一个字符串全部转换成小写
11.java的double类型占用多少位? 64/8
12.常量的命名规则
(1)常量是使用 final 修饰的存储单元
(2)全部为大写字母表示
12.100%3的结果? 1
13.关系运算有什么?
== != >< >= <=
14.关系运算符的结果为什么? true false
15.逻辑短路与和逻辑短路或的解释
对于|| ,只要有一个操作数为true,则结果为true
对于&& ,只要有一个操作数为false,则结果为false
16.说明for循环的循环流程
四个部分：初始化部分 A、循环条件 B、循环体 D、迭代部分 C
for(int i=0;i<20;i++)
{
循环体
}
执行步骤是:
1、i=0 初始化初值；
2、 进行条件判断i是否<20，如果条件为真，则继续执行；
3、执行循环体的代码；
4、i++ 变量i自增一次；
5、回到第2步,一直循环，直到第2步条件为假时, 退出循环，结束。
17.break和continue的作用
break：终止直接包含的循环体，结束（本层）循环
continue：终止本次循环，直接执行循环的下一次
18.“==”和equals的区别
==如果比较的是数值，那么比较的就是数值的大小，如果比较的类，那么比较的就是内存地址
equals方法，如果比较的是一个自定义的类，如果不重写equals方法，那么他将使用Object的equals方法
而 Object的equals方法使用==做比较的，所以比较的是内存地址。如果想让他比较内容的话，那么就要重写equals方法
19.说出五个jdk1.5的新特性
jdk5.0中出现的新特性 泛型（Generics） 增强的“for”循环（Enhanced For loop） 自动装箱/ 自动拆箱（Autoboxing/unboxing） 类型安全的枚举（Type safe enums） 静态导入（Static import） 可变参数(Var args)
20.重写
重写：在不同类中(子父类中)。
方法声明相同(返回类型，方法名，参数列表均相同)。
重写需要注意：
**子类方法的访问权限要大于等于父类方法的访问权限。
**静态只能重写静态。但是这种情况一般不会出现。
21.什么是重载?
重载：在同一类中。方法名相同，参数列表不同。重载可以改变返回类型
22.Integer的取值范围
Integer的取值范围（-2^31~2^31-1）
最小值为 -2^31，最大值为 2^31-1
23.Integer a=128; Integer b=128;输出a==b的结果是什么? false
24.byte的取值范围 -128 至 127
25.说出十进制和二进制的转换技巧?
任意进制转 10（系数*基数的权次幂） 10 进行转任意进制 （除奇倒取余）
快速转换法：8421 码 (128 64 32 16 8 4 2 1) 100000
26.static可修饰什么?
属性,方法,代码块
27.final可以修饰什么?
final 可以修饰： 类 变量 方法
final修饰的类不能被继承。
final修饰的方法不能被重写。
final修饰的变量是一个常量。只能被赋值一次。
28.说说为什么自定义一个类，使用toString输出的不是，这个类的赋值信息?
因为没有重写object的tostring()方法
29.java的访问修饰符有哪些?
public > protected >default> private
30. 为什么静态方法，不能输出普通变量?
因为静态方法是类级别的,随着类的加载而加载,而普通变量要和实例化的那个对象绑定在一起才能够使用，所以就产生了矛盾
31.switch的表达式里面可以放什么数据类型?
java 1.6(包括)以前,只是支持等价成int 基本类型的数据:byte ,short,char,int(其他的都不可以)。 1.7加入的新特性可以支持String类型的数据。
32. int a =i++和 int b =++i有什么区别?
int a =i++ 先赋值给a,i再自增
int b =++i i先自增,再赋值给
前缀形式：
int i = 10;
int a = ++ i; //等同于 i++; int a = i; 所以 a=11， i= 11
后缀形式：
int j = 10;
int b = j++; //等同于 int b = j; j++; 所以 b=10，j = 11
33. 为什么String有length()?
因为string是用char类型的数组实现的,char里边有length()属性,所以string可以调用length();
34.类，方法，常量，包名的命名规则?
1、类名：首字母最好大写。
2、类名：如果有多个单词可以使用_区分，或者：AirBace;第二个单词大写。
3、类名、方法、变量、常量名：只能是字母、下划线、美元$符号开头。
4、方法名首字母小写，如果有多个单词可以使用_区分，或者：airBace;第二个单词大写。
5、变量名跟第4项一样。
6、常量名：全部大写，必须赋值、最好static、final，也就是说定义为静态的、最终的
35.1-100的偶数和? 2550
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i%2==0) {
sum+=i;
}
}
System.out.println(sum); //2550
36. 定义一个map，添加内容（“1”，“2”）（“1”，“3”）（“2”，“4”），循环输出键值对?
Map<String,String> map = new HashMap<String,String>();
map.put("1","2");
map.put("1","3");
map.put("2","4");
Set<Entry<String,String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println("键"+entry.getKey()+"=值"+entry.getValue());
}
37.创建5个学生里面有姓名和年龄，使用Arrays.sort()方法对年龄进行排序，然后输出，并分析程序执行效果?
public static void main(String[] args) {
List<student> list1 = new ArrayList<student>();
list1.add(new student("张三",20));
list1.add(new student("李四",15));
list1.add(new student("张三",18));
list1.add(new student("王五",23));
Set<student> set = new HashSet<student>();
set.addAll(list1);
Collections.sort(list1);
System.out.println(set);
}
39.编写代码比较两个自定义的类是否相等?
1、如果说两个对象的判断可以使用 equals，或者 ==。
2、如果判断对象是否某个类 可以使用 instanceof ，isInstance
3、如果两个类的比较 可以使用 isAssignableFrom，但只能得到是否是自身或者子类的结果，不能完全确定是否相同。
public static void main(String[] args) {
String s1 = new String("javaisland");//测试两个对象是否相同
System.out.println(s1 instanceof String); // true
String s2 = new String("javaisland");//测试是否对象属于某个类
System.out.println(String.class.isInstance(s2)); // true
System.out.println(ArrayList.class.isAssignableFrom(Object.class)); // false
System.out.println(Object.class.isAssignableFrom(ArrayList.class)); // true
}
40.封装一个静态方法（功能自定义）
private static void ceShi(){
System.out.println("标题");}
41.写一个switch语句，根据相应的数字输出星期
public static void main(String[] args) {
int i=0;
switch (i) {
case 0:
System.out.println("星期一");
break;
case 1:
System.out.println("星期二");
break;
case 2:
System.out.println("星期三");
break;
case 3:
System.out.println("星期四");
break;
case 4:
System.out.println("星期五");
break;
case 5:
System.out.println("星期六");
break;
case 6:
System.out.println("星期日");
break;
default:
}
}
42. 对String a="1,5,1,3,2,7",排序并且去重复?
String a="1,5,1,3,2,7";
String[] split = a.split(",");
List<String> list = Arrays.asList(split);
//TreeSet以升序保存对象，所以TreeSet中保存的对象比较能够比较大小
TreeSet<String> treeSet = new TreeSet<String>();
treeSet.addAll(list);
System.out.println(list);
System.out.println(treeSet);
43.自定义对象如何去重
public static void main(String[] args) {
List<student> list1 = new ArrayList<student>();
list1.add(new student("张三",20));
list1.add(new student("李四",15));
list1.add(new student("张三",18));
list1.add(new student("王五",23));
Set<student> set = new HashSet<student>();
set.addAll(list1);
System.out.println(set);
}
44.自定义对象如何排序
//student类，并实现Comparable接口
class Student implements Comparable<Student>{
//姓名，成绩，年龄三个变量
private String name;
private int score;
private int age;
//构造方法
public Student() {}
public Student(String name, int score,int age) {
this.name = name;
this.score = score;
this.age = age;
}
//get set 方法
public String getName() {
return this.name;
}
public int getScore() {
return this.score;
}
public int getAge(){
return this.age;
}
public void setName(String name) {
this.name = name;
}
public void setScore(int score) {
this.score = score;
}
public void setAge(int age){
this.age = age;
}
//重写toString方法
public String toString(){
return "姓名："+this.getName()+"\t成绩："+this.getScore()+"\t年龄："+this.getAge();
}
@Override
//实现Comparable的compareTo方法
public int compareTo(Student stu) {
// TODO Auto-generated method stub
return this.getScore()-stu.getScore();
}
}
public class SortList {
public static void main(String [] args){
//集合的定义
List<Student> list = new ArrayList<Student>();
//学生对象的加入
list.add(new Student("张三",89,20));
list.add(new Student("李四",60,21));
list.add(new Student("路人",99,15));
//排序
Collections.sort(list);
//遍历输出
for(Student stu : list){
System.out.println(stu.toString());
}
}
}
45.定义一个List集合，集合里面放多个自定义的对象，如何完成去重?
public static void main(String[] args) {
List<student> list1 = new ArrayList<student>();
list1.add(new student("张三",20));
list1.add(new student("李四",15));
list1.add(new student("张三",18));
list1.add(new student("王五",23));
Set<student> set = new HashSet<student>();
set.addAll(list1);
System.out.println(set);
}
46.如何创建线程?
第一种方法：继承Thread类
第二种方法：实现Runnable接口
第三种方法：实现callable接口
public class MyThread implements Runnable{
public static void main(String[] args) {
MyThread t = new MyThread();
Thread thread = new Thread(t);
thread.start();
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("运行");
}
}
47.反射创建对象,反射获取，属性，方法，泛型
/*
* 反射:可以在类的运行期间,获取到类的信息(属性 , 方法, 注解, 泛型等等)
* 反射提高了程序的扩展性()
*
* //反射的第一步,都是要获取到Class对象---->>类的信息
*
* */
public class StudentFanShe {
public void lean(){
System.out.println("在学习");
}
public void add(String a){
System.out.println("在学习");
}
public int status;
private String name;
private int age;
public StudentFanShe(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "StudentFanShe [name=" + name + ", age=" + age + "]";
}
public StudentFanShe(){
super();
}
/*
* 三种方式获取到Class
*
*/
@Test
public void getClassTest(){
//1.类名.class student.class
//2.对象名的getClass
StudentFanShe studentFanShe = new StudentFanShe();
Class<? extends StudentFanShe> class1 = studentFanShe.getClass();
//3.Class.forName();
String name = studentFanShe.getClass().getName();
try {
Class<?> forName = Class.forName(name);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*
* JunitTest这个测试工具,要求
* 1.写的测试方法,访问修饰符必须是public的,返回值必须是void
* 2.Test写反射的时候,只能有默认的构造方法,如果有多个构造方法就会报,
* java.lang.IllegalArgumentException: Test class can only have one constructor
*/
@Test
public void getClassInfo(){
//1.
// Class<? extends Class> class1 = Student.class.getClass();
StudentFanShe studentFanShe = new StudentFanShe();
Class<? extends StudentFanShe> class1 = studentFanShe.getClass();
}
//获取构造方法
public static void main(String[] args) {
//1.
// Class<? extends Class> class1 = Student.class.getClass();
StudentFanShe studentFanShe = new StudentFanShe();
Class<? extends StudentFanShe> class1 = studentFanShe.getClass();
//获取构造方法
Constructor<?>[] constructors = class1.getConstructors();
for (Constructor<?> constructor : constructors) {
Class<?>[] parameterTypes = constructor.getParameterTypes();
for (Class<?> class2 : parameterTypes) {
System.out.println("constructor parameter ="+parameterTypes);
}
}
//普通方法,调用一个方法
Method[] methods = class1.getMethods();//利用得到的Class对象的自审，返回方法对象集合
for (Method method : methods) {
if ("lean".equals(method.getName())) {
StudentFanShe newInstance;
try {
newInstance = StudentFanShe.class.newInstance();
System.out.println("调用lean方法 "+method.invoke(newInstance,null));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//获取公共的属性 用public修饰的属性
Field[] fields = class1.getFields();//利用得到的Class对象的自审，返回属性对象集合
for (Field field : fields) {
System.out.println("field for");
try {
StudentFanShe newInstance = StudentFanShe.class.newInstance();
Class<?> type = field.getType();
System.out.println("字符的类型 "+type);
field.set(newInstance, 1);
System.out.println("newInstance.status="+newInstance.status);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("public修饰的属性"+field.getName());
}
//获取私有的属性[获取到全部的属性包括私有的属性]Field
Field[] fields1 = class1.getDeclaredFields();
//获取注解Annotation
Annotation[] annotations = class1.getAnnotations();
//获取泛型Generic, 获取父类泛型是,子类必须要new
Teacher teacher = new Teacher();
Class<? extends Teacher> class2 = teacher.getClass();
Class<?> superclass = class2.getSuperclass();
Type genericSuperclass = class2.getGenericSuperclass();
System.out.println("父类泛型"+genericSuperclass);
System.out.println("父类"+superclass.getName());
}
}
class Teacher extends A1<String>{
}
class A1<T>{
}
48.什么是泛型，泛型的作用?
java 泛型是java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
49.什么是树，为什么有红黑树?
树状图是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合
红黑树是一种比较宽泛化的平衡树，没AVL的平衡要求高，同时他的插入删除都能在O（lgN）的时间内完成，而且对于其性质的维护，插入至多只需要进行2次旋转就可以完成，对于删除，至多只需要三次就可以完成，所以其统计性能要比AVL树好
50.数组结构的特点是什么?
概念：同一种数据类型的集合。
好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
51.list集合的特点
List 中的元素可以重复,有序,List 有索引（下标）的概念,可以有null元素
52.set集合的特点
Set 中的元素不能重复,无序,Set 没有索引的概念,可以有null元素
对于 Set 表示的集合，通常是遍历操作，没有 get()和 set()方法
53. 什么是封装，用代码举例子?
封装就是将属性私有化，提供公有的方法访问私有属性。
做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。
如：private String name;
public String getName(){
return;
}
public void setName(String name){
this.name=name;
}
54. 什么是多态，用代码举例子?
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言
具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
多态有两种表现形式：重载和覆盖
class A{
public String f(D obj){return ("A and D");}
public String f(A obj){return ("A and A");}
}
class B extends A{
public String f(B obj){return ("B and B");}
public String f(A obj){return ("B and A");}
}
class C extends B{}
class D extends B{}
public class testJava{
public static void main(String[] args){
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.f(a1));
System.out.println(a1.f(b));
System.out.println(a1.f(c));
System.out.println(a1.f(d));
System.out.println(a2.f(a1));
System.out.println(a2.f(b));
System.out.println(a2.f(c));
System.out.println(a2.f(d));
System.out.println(b.f(a1));
System.out.println(b.f(b));
System.out.println(b.f(c));
System.out.println(b.f(d));
}
}
55.java异常的体系结构?
Throwable：
|--Error:重大的问题，我们处理不了。也不需要编写代码处理。比如说内存溢出。
|--Exception:一般性的错误，是需要我们编写代码进行处理的。
|--RuntimeException:运行时异常，这个我们也不需要处理。
其实就是为了让他在运行时出问题，然后我们回来修改代码。
56.代码遇到异常，没有进行处理，后面的代码还能执行吗? 不能
57.代码遇到异常要想让后面的代码，继续运行，应该怎么办? try...catch...finally
58. 如何抛出一个编译异常
public class exception{
@Test
public void test() throws LoginException{
A a = new A();
a.setAge(20);
System.out.println(a);
try {
a.ji(0);
} catch (java.lang.Exception e) {
e.printStackTrace();
throw new LoginException();
}
System.out.println("我运行了");
}
}
class A{
privateint age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "A [age=" + age + "]";
}
public void ji(int b){
System.out.println(age/b);
}
}
59.如何抛异常
throw Exception用于抛出异常
boolean testEx2() throws Exception{
boolean ret = true;
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}
60.使用io流，创建一个文件，读取一个文件
public static void main(String[] args){
String fileDir="D:"+File.separator+"hepuwen";
String fileString = "www.txt";
File file = new File(fileDir);
System.out.println(fileDir);
OutputStream outputStream =null;
try{
if (!file.isDirectory()) {
file.mkdirs();
}
String filepathString = fileDir+File.separator+fileString;
File file2 = new File(filepathString);
boolean createNewFile = file2.createNewFile();
//进去读出来写
outputStream = new FileOutputStream(file2);
String string = "学习是你快乐!";
outputStream.write(string.getBytes());
}catch (Exception e) {
e.printStackTrace();
}finally{
try {
outputStream.close();
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
61.之前写的HelloA和HelloB的代码执行流程必须搞明白
HelloB是HelloA的子类
静态代码块>代码块>构造方法>静态方法>普通方法
static a
static b
a的代码块
a的有参构造方法
b的代码块
b的有参构造方法zhangsan
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
6
0- 0
已为社区贡献1条内容
所有评论(0)