带符号右移
"a>>b; "将二进制形式的a逐位右移b位，最高位空出的b位补原来的符号位
无符号右移
"a>>>b;"将二进制形式的a逐位右移b位，最高位空出的b位补0
优先顺序：
语句
条件分支语句
-
if
else if
else
-
switch
switch(XX){
case 1 : XX ;break;
case 2: XX ;break;
default(可有可): XX break;
}
[/code]
switch表达式的返回值必须是下述几种类型之一：int, byte, char, short；
case子句中的值必须是常量，且所有case子句中的值应是不同的；
循环语句
- while
- for
- do while
- for each
修饰符
访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
非访问修饰符
为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值
类与对象
面对对象三特征：封装、继承、多态
- 封装
通过 private、default 、protected、 public 关键字实现属性或法的封装, 仅对外提供公共访问式。
“内聚，低耦合” - 继承
实现数据项和法的隐藏
实现隐藏隔离，允许外部对类做有限的访问,开发者可以由的改变类的内部实现
提了代码的重性 - 多态
个对象变量可以指向多种实际类型对象的现象被称为“多态”
三个必要条件:继承、法的重写、类|指向类对象
多态的好处:
提了代码的维护性（继承保证）；提了代码的扩展性
Java中多态的实现式:接实现，继承类进法重写，同个类中进法重载。类|指向类对象
类
类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态属性
类的定义包括：类声明，类体
类可以看成一类对象的模板，对象可以看成该类的一个具体实例
对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体
对象的创建和使用
- 必须使用new关键字创建对象
- 使用对象（引用）.成员变量或来引用对象的成员变量
- 使用对象（引用）.方法（参数列表）来调用对象的方法
- 同一类的每个对象有不同的成员变量存储空间
- 同一类的每个对象共享该类的方法
构造方法
作用：主要来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符起使在创建对象的语句中。
注意 ：
-
个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们,即构造函数的重载
-
使用new+构造方法创建一个新的对象
-
构造函数的名字必须和所在类名字完全相同
-
构造函数与类同名且没有返回值
-
如果没有编写指定构造函数时，编译会自动添加无参数的构造函数
-
特别： 构造函数不能用final，static，abstract修饰
为什么？
1.final修饰函数的主要目的是避免函数被重写，构造器不是通过继承得到的，所以没有必要把它声明为final的。
2.同理，一个抽象的构造器将永远不会被实现，所以它也不能声明为abstract的。
3.构造器总是关联一个对象而被调用，所以把它声明为static是没有意义的。
重载与重写
方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。
调用时，系统会根据不同的参数表选择对应的方法
重载：
- 必须载同个类中
- 法名相同
- 法的参数的个数、顺序或类型不同
- 与法的修饰符和或返回值没有关系
- 可以有同的返回类型，只要参数列表不同就可以了；
- 可以有不同的访问修饰符；
3、可以有不同的访问修饰符；
重写：
6. 重写的法必须要和类模样(包括返回值类型,法名,参数列表)
7. 重写的法可以使@Override注解来标识
8. 类中重写的法的访问权限不能低于类中法的访问权限
权限修饰符 : private < 默认(什么都不写) < protected < public
常用关键字
this
Java中为解决变量的命名冲突和不确定性问题，引关键字this代表其所在法的当前对象的引,使用this可以处理方法中成员变量和参数重名的情况
- 构造法中指该构造器所创建的新对象；
public class B{
A a;
public B(A a){
this.a = a;
}
}
[/code]
- 法中指调该法的对象；
public class Baby{
public void wakeUp(){
System.out.println("宝宝醒啦");
}
public void eat(){
this.wakeUp();
System.out.println("吃东");
}
}
[/code]
- 在类本身的法或构造器中引该类的实例变量（全局变量）和法
public void setName(String name){
this.name=name
}
[/code]
this只能在类中的静态法中使，静态法和静态的代码块中绝对不能出现this
原因:static法在类加载时就已经存在了，但是对象是在创建时才在内存中成
static 关键字
在类中，用static声明的成员变量为静态成员变量，它是该类的公用变量，在第一次使用时被初始化，对应该类的所有对象来说，static成员变量只有一份
-
在类的定义体中、方法的外部可包含static语句块
-
static语句块仅在其所属的类被载入时执行一次
-
用static声明的方法为静态方法，在调用方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
静态方法不再是针对某个对象调用，所以不能访问非静态成员
-
被static修饰的变量属于类变量，可以通过类名.变量名直接引，不需要new出个类来
-
被static修饰的法属于类法，可以通过类名.法名直接引，不需要new出个类来
类的成员变量包括实例变量和类变量，实例变量在不同对象互不相同，类变量被所用对象共享。
包
package语句作为jaa源文件的第一条语句，指明该文件中定义的类所在的包（若缺省该语句，则指定为无名包）
JDK包介绍
java.lang——包含一些java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能
java.awt——包含了构成抽象窗口工具包（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）
java.applet——包含applet运行所需的一些类
java.net——包含执行与网络相关的操作的类
java.io——包含能提供多种输入/输出功能的类
java.util——包含一些使用工具类，如定义系统特性，使用与日期日历相关的函数
打包命令：jar –cvf xx.jar .
访问控制
子类和继承
java中使用extends关键字实现类的继承机制
通过继承，子类自动拥有了基类（superclass）的所有成员（成员变量和方法）
Object类是所有Java类的最高层父类
java只支持单继承，不允许多继承
一个子类只能有一个基类，一个基类可以派生出多个子类
子类继承的方法只能操作子类继承和隐藏的成员变量。
子类重写或新增的方法可以操作子类继承和新声明的成员变量，但是不能直接操作隐藏的成员变量
子类的继承性
如果子类和父类在同一个包，那么子类可以继承父类中的所有的非private变量和方法。
如果不在同一个包，那么父类中的private和友好访问权限的成员变量和方法不会被子类继承。
继承中的构造方法
子类的构造的过程必须调用其基类的构造方法
子类可以在自己的构造方法中使用super调用基类的构造方法，使用this调用本类的另外的构造方法
使用super，必须写在子类构造方法的第一行
如果子类的构造方法没有显示地调用基类构造方法，则系统默认调用基类无参数的构造方法
如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错
对象转型
-
一个基类的引用类型变量可以“指向”其子类的对象
-
一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）
-
可以使用引用变量instanceof类名来判断该引用型变量所“指向”的对象是否属于该类或该类的子类
-
子类的对象可以当做基类的对象来使用称作向上转型（upcasting)，反之称为向下转型（downcasting）
向上转型:
class A {
public void print() {
System.out.println("A:print");
}
}
class B extends A {
public void print() {
System.out.println("B:print");
}
}
public class Test{
public static void main(String args[])
{
A a = new B();
a.print();
}
}
[/code]
向下转型:
class A {
public void print() {
System.out.println("A:print");
}
}
class B extends A {
public void print() {
System.out.println("B:print");
}
public void funcB(){System.out.println("funcB");
}
}
public class Test{
public static void main(String args[])
{
B b = (B)a;
b.funcB();
}
}
[/code]
多态
定义：多态是同个为具有多个不同表现形式或形态的能。
一个对象只能有一种确定数据类型
一个引用类型变量可能指向（引用）多种不同类型的对象
实现继承
方法重写
父类引用指向子类对象
抽象类
public abstract class Action {
public abstract void doSomething();
public void test(){
};
}
[/code]
- 用abstract关键字来修饰一个类时，这个类叫做抽象类，用abstract来修饰一个方法时，该方法叫做抽象方法
- 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
- 抽象类不能被实例化
抽象方法只需声明，而不需实现
常用关键字
super关键字
-
super关键字主要存在于类法中，于指向类对象中的类对象；可以访问类的属性、函数以及构造函数。
-
类存在着同名的成员（包括变量和法）时，在类中默认是访问类的成员，可以通过super关键字指定访问类的成员；
-
默认会先调类参的构造法，可以通过super关键字指定调类的构造法。
final
可以修饰：类，成员变量和方法中的局部变量
final的变量的值不能够被改变
final修饰类：不能被继承
Final修饰法： 不能被重写，但是类可以类中final修饰的法
final修饰变量：
-
基本类型变量使final修饰了就不可变了，成员变量或局部变量被修饰为final就是常量，声明常量时必须指定常量的值
-
对于引类型变量被final修饰了:引变量引不可变，但是引对象的内容可以改变。
接口
- 接口中只能有常量和abstract方法
- 多个无关的类可以实现同一个接口
- 一个类可以实现多个无关的接口
- 与继承关系类似，接口与实现类之间存在多态性
语法格式：
< modifier > class < name > [ extends< superclass > ] [ implements < interface > ,< interface > ]
public interface UserService {
int age = 99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
[/code]
- 接口中声明属性默认为public static final的；也只能是public static final的；
- 接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的
- 接口可以继承其他的接口，并添加新的属性和抽象方法
接口和类的比较
- 接口与类相似点：
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。 - 接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
| 实体类 | 抽象类 | 接口 |
|---|
| 常量 | 常量 | 常量 |
| 变量 | 变量 | 抽象方法 |
| 方法 | 方法 | |
| 抽象方法 | |
异常类
异常是在运行期出现的错误
- Java异常是Java提供的用于处理程序中错误的一种机制
- 所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在）
- 设计良好的程序应该在异常发生时提供处理这些错误的地方，使得程序不会因为异常的发生而阻断或产生不可预见的结果
- Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出（throw）异常
- 当Java运行时系统接收到异常对象时，会寻求能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常
异常和错误的区别是：异常能被程序本身可以处理，错误是法处理。
异常的分类
-
Error：称为错误，由Java虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不做处理
-
Exception：所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显式的声明或捕获
Exception（异常）分两类：运时异常和运时异常(编译异常)。
运时异常：
如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常)
等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
运时异常 （编译异常）：
是RuntimeException以外的异常，类型上都属于Exception类及其类。从程序语法度讲是必须进 处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及户定义的Exception异常.
-
Runtime Exception：一类特殊的异常，如被0除、数组下标越界等，其产生比较频繁，处理麻烦，如果显式的声明或捕获将会对程序可读性和运行效率影响很大，因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）
代码
try{
}catch(SomeException1 e){
……
}catch(SomeException2 e){
......
}finally{
……
}
[/code]
java中的常用类
String 类
string类是不可以变序列
String不变的性质是因为每次都从String 池取，如果有则直接，否则创建新的放
静态重载方法
public static String valueOf(…)可以将基本类型数据转换为字符串
String类初始化
String str1 = “HelloWorld”;
Sting str2 = new String();
str2="HelloWorld"
String str3 = new String(“HelloWorld”);
[/code]
String 类的常见操作
1 char charAt(int index)
返回指定索引处的 char 值。
String concat(String str)
将指定字符串连接到此字符串的结尾。
int indexOf(char ch)
返回指定字符在此字符串中第次出现处的索引
boolean equals(Object anObject)
将此字符串与指定的对象较。
String replace(char oldChar, char newChar)
返回个新的字符串，它是通过 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replaceAll(String regex, String replacement)
使给定的 replacement 替换此字符串所有匹配给定的正则表达式的字符串。
int compareTo( NumberSubClass referenceName )
如果指定的数与参数相等返回0。
如果指定的数小于参数返回 -1。
如果指定的数大于参数返回 1。
[/code]
基本数据类型包装类
Integer i1 = new Integer(8);
Integer i2 = Integer.valueOf(8);
Integer i3 = 8;
[/code]
- 动拆箱
动拆箱即动将包装类型转换成基本数据类型，与动装箱相反
//早期包装数据类型->基本类型转换
Float i=3.3;
float i5 = i.floatValue();
Integer i2=3;
int m=i2.intValue();
Integer i=3;
int i4 = i;
[/code]
多线程
线程和进程的区别
- 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销
- 线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程都有独立的运行栈和程序计数器（PC），线程切换开销小
多进程：在操作系统中能同时运行多个任务（程序）
多线程：在同一应用程序中有多个顺序流同时执行
线程的基本概念
-
Java的线程通过java.lang.Thread类来实现的
-
VM启动时，会有一个由主方法（public static void main())定义的线程
-
可以通过创建Thread类的实例来创建线程
-
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体
-
通过调用Thread类的start()方法来启动一个线程
线程的创建
Java中线程的创建常有如2种基本形式
1.继承Thread类，重写该类的run()法
class MyThread extends Thread {
private int i = 0;
@Override
public void run() {
for (i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
[/code]
2、实现Runnable接，并重写该接的run()法，该run()法同样是线程执体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象
class MyRunnable implements Runnable {
private int i = 0;
@Override
public void run() {
for (i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
[/code]
Thread myThread=new Thread(target);//target为Runnable接口类型
Runnabel接口中只有一个方法
public void run();//用以定义线程运行体
使用Runnable接口可以为多个线程提供共享的数据
在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法
public static Thread currentThread()获取当前线程的引用
线程控制基本方法
由于是静态方法，sleep可以由类名直接调用
sleep()法和wait()法：
- 相同点：旦执法以后，都会使得当前的进程进阻塞状态。
- 不同点：
- 法声明式不同，sleep()法在Thread类中声明，wait()法在Object类中声明。
- 调的条件不同，sleep可以在任何需要的场景下调，wait必须使在同步代码块或者同步法中。
- 是否释放锁，sleep不会释放，wait会释放
- sleep()法 :sleep()使当前线程进阻塞状态，在指定时间内不会执。动苏醒
wait()法: 不会主动苏醒，需要另外的线程调notify()/notifyAll()法唤醒。
进程状态
1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
问答题
- 面向对象的特征有哪些方面 ？
答：主要有以下四方面：
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
- 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
- String是最基本的数据类型吗？
答：基本数据类型包括byte、int、char、long、float、double、boolean和short。（8个）
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
- int 和 Integer 有什么区别？
答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
- 一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
答：可以。必须只有一个类名与文件名相同。
- 阐述实体类、抽象类和接口的区别
1、类只能继承类，接口只能继承接口，类可以实现接口，其它都不行。
2、java中支持单继承，多实现规则。
抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。
- 重载和重写的区别
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型
- throws 关键字和 throw 关键字有什么区别和联系？
throw来在法体内抛出异常，throws来在法声明处声明异常。
这两个关键字有着定的联系。如果个法中使了throw关键字抛出了异常，那么要么即try/catch语句进捕获，要么就是throws进声明，否则将出现编译错误。
然， 并不是只有使了throw关键字之后才能使throws关键字，语法上来说，任何个法都可以直接使throws关键字，抽象法也可以使。
- 什么是多态？如何实现多态？
多态性(Polymorphism)是指在基类中定义的属性或法被派类继承后，可以具有不同的数据类型，或表现出不同的为，从使得同个属性或法在基类及其各个派类中具有不同的语义。
Java的多态性体现在两个：(1) 法重载实现的静态多态性，称为编译时多态；(2) 法覆盖/重写实现的动态多态性，称为运时多态。
- error和exception有什么区别
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况
- 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数
来源：https://blog.csdn.net/u011612364/article/details/117881835
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
照妖镜
