Java核心概念详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_38070406/article/details/76611385

javac.exe是编译功能javaCompiler
java.exe是执行class，如果没有编译的话是不能执行的，同理，javac.exe编译完以后如果没有java.exe执行的话也是没有运行的

Java关键字：
java中的关键字全部都是小写的，所以NULL错误
类，方法修饰符，程序控制（break,continue,return,do,while,if,else,for,instanceof,swith,case,default)，错误处理(try,catch,throw ,throws)，包相关(import,package)，基本类型(boolean,byte,char,double等），变量引用（super,this,void)，保留字（goto,const)

标识符：
标识符只能以字母，数字，下划线和美元符号符号组成，并且标识符的第一个字符必须字母，下划线，美元符号，不能是数字开头。
类名也可以下划线开头。

Hashmap和Hashtable:
Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。 L ist 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复

HashMap不能保证元素的顺序
Hashtable不允许null键或值，Hashmap可以
在java.util.HashMap中，总体来说是使用的链地址法来解决冲突的。
Map是一个接口，hashtable,hashmap都是它的实现。
HashMap是非synchronized，而Hashtable是synchronized即Hashtable类是同步的，而HashMap类不是同步的
HashTable使用Enumeration，HashMap使用Iterator

Hashtable不能将键和值设为null，否则运行时会报空指针异常错误；
HashMap线程不安全，Hashtable线程安全
Vector是线程安全的ArrayList
TreeSet和LinkedList都不是线程安全的

Collection主要的子接口:
List:可以存放重复内容
Set:不能存放重复内容,所有重复的内容靠hashCode()和equals()两个方法区分,仅仅使用equals()来判断元素是否相等是不正确的。
Queue:队列接口
SortedSet:可以对集合中的数据进行排序

运行时异常故名思议就是程序在运行的时候出现异常，隐含的一个前提就是程序在编译时是检测不到异常的存在，作者本人也并不知道是否自己的代码中含有运行时异常，所以根本也不可能提前使用try{}catch{}捕获．

普通的类不能用private修饰

A：垃圾回收程序是一般是在堆上分配空间不够的时候会自己进行一次GC，程序员不需要也不能主动释放内存。
B：Java的内存释放由垃圾回收程序来进行释放
C：在Java里，内存的释放由垃圾回收程序进行管理，程序员不能直接进行释放。
D：程序员可以调用System.gc()运行垃圾回收器，但是不能指定时间。

因为是常量所以要用final限制

初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。
执行顺序：
父类静态代码块-》子类静态代码块-》父类构造代码块-》父类构造函数-》子类构造代码块-》子类构造函数

在java中一个unicode占2个字节（byte）。
一个字节等于8比特位（bit）。
所以每个Unicode码占用16个比特位。

重写和重载：
方法的重写（override）两同两小一大原则：
方法名相同，参数相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

方法的**重载**Overload要注意以下的几点：
①在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序；
②不能通过访问权限、返回类型和抛出异常的差异进行重载；

因为调用的时候不知道调用的是哪个函数

③方法的异常类型和数目不会对重载造成影响；

总是傻傻分不清重载和重写，一直是按照overriding和overload记忆的，中文真是博大精深啊。
重写（overriding）：只有实现的功能代码不一致，其他的（函数名、参数列表、返回值类型）必须都一致。
重载（overload）：只要方法名一致，其他（参数列表、返回值）怎么折腾随便。重载只要求参数列表不同，返回值无关。
重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了。

==是判断地址，string的tolowercase很明显是拿着原有的字符串又new了个地象，所以地址不一样

接口
1、一个类可以有多个接口；
2、一个类只能继承一个父类；
3、接口中可以不声明任何方法，和成员变量
interface testinterface{

}

接口必须public。所以实现这个接口的方法的修饰也是public。因为
哪些不能修饰接口？子类的权限不能比父类更低
private protected static
接口允许定义成员，但必须是常量。
接口中只有常量定义，没有变量声明。
interface中的方法默认为public abstract 的，变量默认为public static final
接口里的方法只能用 public 和 abstract 修饰，如果你不写也没关系，默认的也是 public abstract 修饰.
方法不能写static

接口可以继承多接口

public class Test1 extends Test2 implements Interfase2
实现类和继承接口的顺序不能反，必须是先实现类再继承接口，否则报错。

静态的内部类才可以定义static方法

数据类型：
包装类是针对基本数据类型的。

如果不明确指定，整数型的默认是 int类型，带小数的默认是 double类型
Java中的四类八种基本数据类型第一类：整数类型 byte short int long 第二类：浮点型 float double 第三类：逻辑型 boolean(它只有两个值可取true false) 第四类：字符型 char
注意整数类型和整形的区别。
数据类型转换问题。由大到小需要强制转换，由小到大不需要。
没有强制类型转换是会出错的。
自动转换按从低到高的顺序转换。不同类型数据间的优先关系如下：
低 ———————————————> 高
byte->char->short-> int -> long -> float -> double

byte和short型在计算时会自动转换为int型计算，结果也是int 型。所以a1*a2的结果是int 型的
没有final修饰的变量相加后会被自动提升为int型，与目标类型byte不相容，需要强制转换（向下转型）

java支持的语言类型分为：基本类型和引用类型。
基本类型包括boolean类型和数值类型，数值类型分为整型和浮点类型，整型包括：byte、short、int、long、char，浮点类型包括float和double。
引用类型包括类、接口和数组
Byte和Float属于基本类型的包装类型，属于引用类型。啥都不说，注意大小写

用new创建的对象在堆区
函数中的临时变量在栈去
java中的字符串在字符串常量区

System.out.println();
System是java.lang包下的一个类，out为System的final静态成员（PrintStream类型），println()是PrintStream类的实例方法。

static用来修饰类或类的成员，这时不需要创建实例就能访问（而且不能实例化），在被调用的时候自动实例化，且在内存中产生一个实例。当含有静态成员的非静态类实例化出对象后，这些对象公用这些静态成员，通过类名或对象名都能访问它们

只有%取余操作，只适用于整型

final
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖和类不可被继承（即不能再派生出新的子类）。

final属性：被final修饰的变量不可变，由于不可变性有两层含义，一是引用不可变，二是对象不可变。final修饰的属性在第一次被赋值后不可再更改值。

final修饰的变量是常量，必须进行初始化。初始化的方法有1.在定义的时候初始化2.final成员变量可以在初始块中初始化，但不可在静态初始块中初始化3.静态final成员变量可以在静态初始化块中初始化，但不可在初始化块中初始化4.在类的构造器中初始化，但静态final成员变量不可在构造函数中初始化。

final方法：当一个方法声明为final时，该方法不允许任何子类重写这个方法。但是可以重载
final类：当一个类被声明为final时，此类不能被继承，所有方法都不能被重写。值得注意的是，一个类不能既被声明为abstract，又被声明为final

const是C和C++中的常量关键字，在java中为final
final 定义变量，可以用 static 也可以不用。

final与private的比较
private方法只可以在类的内部使用，在类外根本访问不到，而final方法可以在类外访问，但是不可以重写该方法，就是说可以使用该方法的功能但是不可以改变其功能，这就是private方法和final方法的最大区别

静态成员和静态方法，可以直接通过类名进行调用；其他的成员和方法则需要进行实例化成对象之后，通过对象来调用。
非静态变量不能够被静态方法引用

Math.Ceil和floor：
ceil:天花板，向上取整。
floor:地板，向下取整。
Math.floor(x) 返回小于等于x的最接近整数，类型为double

构造方法：
类的构造方法:（1）无返回值；（2）其名称与本类名称相同。
方法可以和类同名
构造函数可以重载
如果父类中只有有参构造函数，则子类构造函数必须调用。
在普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值
构造函数不能被继承，构造方法只能被显式或隐式的调用。

public：可以被所有其他类所访问;
protected：自身、子类及同一个包中类可以访问;
default：同一包中的类可以访问;
private：只能被自己访问和修改。
public>protcted>default>priavte

默认权限为当前类和同一包，子孙类不能访问，其他包更不能访问
private当前类使用，public无使用限制 protected同一包或子类中使用

getParameter()是获取POST/GET传递的参数值；
getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
getAttribute()是获取对象容器中的数据值；
getRequestDispatcher是请求转发。

A,D是正确的；创建Statement是不传参的，PreparedStatement是需要传入sql语句

switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持。

简单记忆线程安全的集合类：喂！SHE！喂是指 vector，S是指 stack， H是指 hashtable，E是指：Eenumeration

String str1=”hello”; 这样创建字符串是存在于常量池中
String str2=new String(“hello”); str2存在于堆中，
==是验证两个对象是否是一个（内存地址是否相同）
用+拼接字符串时会创建一个新对象再返回

数组复制方法：
效率：System.arraycopy > clone > System.copyOf > for循环

抽象类
4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类
abstract class abstclass{
abstract void meth();
}

抽象类不能被实例化，但是可以被继承。
特点:
1.抽象类中可以构造方法
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。

对于abstract类的子类来说有两种途径，一种是实现其超类的所有abstract方法；或者是 //子类也声明为abstract类，将全部实现抽象方法的责任交给它的子类。

abstract只能用来修饰类、方法，不修饰字段（属性）
抽象方法用“;”结束
抽象方法没有方法体，也不用大括号。

抽象类是可以实现接口的，而且抽象类也可以继承自抽象类
抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含.abstract方法不能有函数体
抽象类和接口都是不能被实例化的
1）抽象类可以包括抽象方法和非抽象方法
2）如果类里面有抽象方法的话，那么类一定要声明为抽象的！

接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，成员变量默认为pubLic static final，且必须赋初值。
3.在接口中的方法，永远都被public abstract来修饰，且只能被这个两个关键字修饰，没有方法体。
总结以上两点：
接口中默认修饰变量属性用：public static final；而默认方法的修饰符是：public abstract

4.接口中没有构造方法，也不能实例化接口的对象。
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类

java是强类型语言，所有的方法必须放在类里面，包括main
,java中可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口
内部类的类名一般与文件名不同

String的长度用str.length(); 注意不是str.length

JDK中提供的java、javac、jar等开发工具也是用Java编写的，底层实现c语言

equals和==的区别
System.out.println(classa.equals(classb)); 如果这这样输出答案也是错误的因为子类没有覆盖Object
的equals()方法,而默认调用==的这个方法判断两个对象是否相等需要覆盖equals()方法和hashcaode()方法
==判断的是对象引用地址是否相同

String str=new String(“hello”);
这句话new了一个新的String对象，所以地址与”hello”字符串常量的地址不同，答案为false

如果判断字符串是否相等应给用str.equals(“hello”)方法

ArrayList和LinkedList
Vector支持线程的同步，也就是内部加锁的
但是效率低，因此在新版jdk中加入线程不安全的Arraylist
Vector与ArrayList一样，也是通过数组实现的

两者都是实现了List接口，注意不是继承。

ArrayList底层是数组，所以查询快，增删慢；而LinkedList底层是链表，查询慢，增删快。

JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。

编码方式：
编码格式由浏览器决定，浏览器根据html中指定的编码格式进行编码，tomcat根据指定的格式进行解码，另外get请求和post请求对编码格式的处理也是不同的

“|”与”||”的区别
“|”是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2
“||”是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2

父类和子类的关系
如果父类里被private修饰，则子类是无法继承和访问的，而父类访问子类，需要new一个对象才能访问，不能直接访问

混合赋值运算符的使用
<<表示左移位
// >>表示带符号右移位
// >>>表示无符号右移
但是没有<<<运算符

线程：
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
注意打印语句是一条主线程，默认会先执行。加jion()方法后保证想要的线程执行。

由于replaceAll方法的第一个参数是一个正则表达式，而”.”在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/”。如果想替换的只是”.”，那么久要写成”\.”.，一开始没看懂

java语言是强类型语言，支持的类型分为两类：基本类型和引用类型。
基本类型包括boolean类型和数值类型，数值类型有整数类型和浮点类型。整数类型包括：byte、short、int、long和char；浮点类型包括：float和double
引用类型包括类、接口和数组类型以及特殊的null类型。

Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢

Base base = new Son();
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过。编译看左边，运行看右边。由于没编译Son son;

向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化

&&当第一个条件不成之后，后面的条件都不执行了，而&则还是继续执行，直到整个条件语句执行完为止

transient:
一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
这个类的有些属性需要序列化，而其他属性不需要被序列化；
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

整数类型默认为 int
带小数的默认为 double

下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：
byte[] src,dst;

dst=new String(src，”GBK”).getBytes(“UTF-8”)
操作步骤就是先解码再编码
用new String(src，”GBK”)解码得到字符串
用getBytes(“UTF-8”)得到UTF8编码字节数组

合法的 Java 标识符不应该包含& 或者小数点.

long a = 1;int b = a + 1;
只能想上转型。相当于一桶水不能倒进一杯水中，一杯水却可以倒进一桶水中。