1
switch类型可以对int型，char类型和String类型进行判别。
2
简洁写法,不用if进行判断。
int score =61;
boolean is = score > 60;
3
Java逻辑运算中有长路类型的运算，如&。
该运算计算的方式是关系式1&关系式2。
例子：
4<3&5*3<12
先计算4<3为false
再计算5*3<12为false
false与false为false
短路类型的运算不同，如&&
4<3&5*3<12
先计算4<3为false
第一个false后不再计算进行计算，整个表达式变为false。
4
Package在磁盘中存取时为文件名。
导入和导出文件时可以是zip文件。
5
静态变量是由JVM自动进行初始化。
当Main函数与想要使用的方法在同一个类中时，使用的方法必须要加上static。
6
类名称通常都是大写的，方法名称如何有两个单词那么第二个单词一般大写，而第一个单词是小写。
实例化类的时候通过栈内存指向堆内存，例如：
Person per =new Person();
per变量存储为栈内存空间，其指向为堆内存空间。
7
面向对象三大特征：
封装
继承
多态（重载，对象多态）
8
Java属性和方法的封装是通过关键字private来实现。
实现该属性用get和set方法。利用get和set方法有好处，可以在get或者set方法中加入一些输入限制。
9
如果使用对象只使用一次，那么就可以用匿名对象，匿名对象只使用一次。比如Person这个类，Person类中有公有方法tell，匿 名使用方式如下所示：
new Person().tell();
10
当用户自己定义构造方法后，系统不再自己生成一个没有参数的构造方法。
11
String类型不是引用传递，传递到函数中不可以进行更改。类的对象属于引用传递，传递到函数中时可以进行更改。
12
this在构造方法中调用另一个构造方法的时候必须要放在首行，否则编译出现错误。
class Person
{
int age;
public Person(int age)
{
this();
this.age=age;
}
public Person()
{
System.out.println("Empty");
}
}
13
static可以节省内存。比如在一个类中，设置一个静态变量。所有的对象都有一个公有的静态变量。
使用static方法的时候，只能访问static的属性和方法，而非static的属性和方法不能进行访问。
14
Java只允许单继承。
15
在子类对象实例化之前，必须先调用父类构造函数，然后再是子类构造函数。
16
子类重写父类的方法时，需要方法名和参数完全相同。子类使用父类重写的方法时可以运用super关键字。
被子类重写的方法不能有比父类更加严格的访问权限。
17
访问权限：private<default<public。
private只有在本类中进行访问，default只能在本包下进行访问，而public在整个工程下可以进行访问。
18
重写与重载的区别：
19
使用final声明的类不能被继承。
使用final声明的方法不能被重写。
使用final声明的变量不能被修改。
20
抽象类被子类继承，子类必须重写抽象类中的所有抽象（！！！）方法。
21
接口是一种特殊的类，里面全部由全局(static)常量(final)和公共的抽象方法组成。
一个类可以同时继承抽象类和实现接口。
一个接口不能继承一个抽象类，但是可以通过extends同时继承多个接口。
22
实例化String对象的时候有两种方式：
1:
String str = new String ("Hello");
采用这种方式时会在内存空间开辟两个空间存储hello。
2：直接赋值。
String str = "Hello";
只在内存中开辟一个空间进行存储，更加节省空间。
23
String类型进行比较的时候不要用“==”进行比较，要用equals进行比较。
双等比较的是地址，equals比较的是内容。
String str = "Hello";
String str1 = new String ("Hello");
String str2 = "Hello";
System.out.println(str==str1);
System.out.println(str.equals(str1));
System.out.println(str==str2);
运行结果：
24
string内容字符串是不可更改的，最后改变的是堆内存地址的指向，String类型作为参数传递进去后无法进行更改。
25
string类型中有toCharArray方法，可以将string类型转换为字符数组。
String name = "Good";
char data[]=name.toCharArray();
charAt：从字符串中取出指定的字符。
String name = "Good";
System.out.println(name.charAt(0));
byte：字符串和byte数组进行转换。
String name = "Good";
byte[] bytes=name.getBytes();
indexof：返回第几个字符，看是否存在某个值，如果不存在字符，则返回-1。
String name = "Good";
System.out.println(name.indexOf(‘o‘));
System.out.println(name.indexOf(‘a‘));
System.out.println(name.indexOf("oo"));
trim：去掉字符串的前后空格。
subString：从字符串中取出子字符串，记住返回的是string类型。
toLowerCase，toUpperCase：转换成小写，大写。
endswith,startwith：返回布尔类型，判断字符串的开头结尾字符。
replace：返回一个字符串，替换String类型中的一个字符。
26
StringBuffer是一个缓冲区，与String类型不同的是StrnigBuffer可以进行修改。
append：追加
insert：插入
indexof：返回第几个字符，看是否存在某个值，如果不存在字符，则返回-1。（与String类型一样）
String和StringBuffer的区别：
String str ="Helloooo";
for(int i = 0;i<100;i++)
{
str+=i;
}
System.out.println(str);
StringBuffer sb = new StringBuffer();
sb.append(str);
for(int i = 0;i<100;i++)
{
sb.append(i);
}
System.out.println(sb);
在上述代码中，使用String类需要开辟100次空间，而使用StringBuffer则不用开辟那么多次空间，因此效率比String好。
27
StringBuilder被设计为StringBuffer的一个简易替换，在单线程的操作中，优先考虑该类，速度比StringBuffer快。
涉及到线程安全的问题，建议使用StringBuffer。
append：追加
insert：插入
28
多态性：
方法的重载与重写
对象的多态
向上转型：程序自动完成
父类对象=子类实例。
！！父类被重写的方法将会被改变。
B bb = new B();
A a =bb;
a.tell1();
a.tell2();
向下转型：强制完成
子类对象=父类实例。
欲向下转型必先向上转型。
A a =new B();
B b =(B)a ;
b.tell1();
b.tell2();
b.tell3();
使用多态性可以节省代码。
package Test1;
class A
{
public void tell1()
{
System.out.println("A----tell1");
}
}
class B extends A
{
public void tell2()
{
System.out.println("B----tell2");
}
}
class C extends A{
public void tell3()
{
System.out.println("C----tell3");
}
}
public class Test2 {
public static void main(String[] args){
say(new B());
say(new C());
}
public static void say(A a)
{
a.tell1();
}
}
以上代码默认使用了自动向上转换，如果不利用多态性，代码会比较复杂，如下：
public class Test2 {
public static void main(String[] args){
say(new B());
say(new C());
}
public static void say(B b)
{
b.tell1();
}
public static void say(C c)
{
c.tell1();
}
}
如果say的参数类型有100个，那么将写100个这种类型的方法，这样写麻烦很多。
29
instanceof 判断是否属于同一个类。
A a =new A();
System.out.println(a instanceof A);
System.out.println(a instanceof B);
A a1 = new B();
System.out.println(a1 instanceof A);
System.out.println(a1 instanceof B);
30
最好不要去继承一个已经完成好的类，没完成好的类里面最好是有抽象方法。
31
接口的使用，接口里面默认的方法是抽象方法。
package Test1;
interface USB
{
void start();
void stop();
}
class C {
public static void Work(USB usb)
{
usb.start();
System.out.println("Working");
usb.stop();
}
}
class USBDisk implements USB{
public void start() {
System.out.println("USB Start");
}
public void stop() {
System.out.println("USB Stop");
}
}
class Printer implements USB{
public void start() {
System.out.println("Printer Start");
}
public void stop() {
System.out.println("Printer Stop");
}
}
public class Test2 {
public static void main(String[] args){
C.Work(new USBDisk());
C.Work(new Printer());
}
}
32
System.err.println("Hello World");
33
finally：里面的代码无论发生什么都会执行。
throws：将异常抛出，将异常抛给方法的调用者来进行处理。
throw：抛出一个实例化异常。
public class Test2 {
public static void main(String[] args) throws Exception {
try {
throw new Exception("Hello");
} catch (Exception e) {
System.out.println(e);
}
}
public static void tell(int a , int b)throws ArithmeticException{
System.out.println(a/b);
}
}
自定义异常：
class Exc extends Exception{
public Exc(String msg){
super(msg);
}
}
public class Test2 {
public static void main(String[] args) throws Exception {
try {
throw new Exc("Good");
} catch (Exc e) {
System.out.println(e);
}
}
}
