Core Java 的知识点总结

最新推荐文章于 2024-05-31 09:34:00 发布

随遇而安-抖抖

最新推荐文章于 2024-05-31 09:34:00 发布

阅读量2.2k

点赞数 6

分类专栏： Core Java 文章标签： Core Java

本文链接：https://blog.csdn.net/weixin_41898352/article/details/79936664

版权

Core Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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));
}
}