Java高级

例子：
public class Student{}
Student student = new Student();

例子：
//重写clone();方法
@Override
public Object clone() {
Car car = null;
try {
car = (Car) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return car;
}

例子：public class Student{
               int a ;//属性
               public int b(){ return a; }//方法
}

方法是由，访问修饰符+返回值+方法名+参数列表组成的

访问修饰符：public ，protected，默认修饰符，priavte
                    其他地方>子类>同包>同类
                    从大到小排列

方法返回值：无返回值，void
                    有返回值，创建方法是添加返回值，有返回值需要return同类型的值

参数：

方法重载

构造方法分为：
有参构造方法和无参构造方法，创建一个对象时，会自动调用该类的无参构造方法。

例子：public class Student{
              public Student(参数列表){}
           }

类变量(静态变量)和实例变量的区别：
类变量：
1.被static修饰的变量，优先于对象存在。

2.随着类的加载而加载，在内存中只有一个拷贝。

3.类内部，可以在任何方法内直接访问静态变量。

4.其他类中，可以直接通过类名访问。
实例变量：
1.没有被static修饰的变量。

2.每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中又多个拷贝，互不影响。

普通代码块：在方法或语句中出现的{}就称为普通代码块。
普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行”

直接在类中定义且没有加static关键字的代码块称为{}构造代码块。
构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。
每个静态代码块只会执行一次。
由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。
如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。

父类 || 超类 || 基类

子类 || 派生类

共有的，最高的访问级别，类的public成员所有类的成员都可以访问

受保护的，类的protected成员只能被该类的成员以及其子类成员访问。还可以被同意豹中的其他类的成员访问

类的成员什么修饰符都没有，又叫包修饰符，只有类本身成员和当前包下类的成员可以访问

私有的，不对外公开的，累的private成员只能被该类的成员访问，访问级别最低

方法重载属于编译时多态

方法重写属于运行时多态

public void feed(Pet p) {
       if (p instanceof Dog) {
              System.out.print("喂骨头");
       } else if (p instanceof Penguin) {
              System.out.print("喂鱼");
       }
}

详情见javaAPI（Java帮助文档）

例子：String s = "AbcDefG";
          String st = new String("ABcDefG")
          String str = new String();     str = "";

判断功能

获取功能

转换功能

替换功能

比较功能

.valueOf(char[] data, int offset, int count)
返回 char 数组参数的特定子数组的字符串表示形式。

append()添加

insert(int index, String str)插入

deleteCharAt(int index)

delete(int start, int end)

StringBuffer replace(int start, int end, String newStr)

String substring(int start)

String substring(int start, int end) //返回一个新的字符串对象，对原来的StringBuffer对象没有影响

反转字符串reverse()

构造方法：
Date date = new Date();
Date date = new Date(Long类型引用);

第一种是 Calendar nowTime = new GregorianCalendar();

第二种是Calendar calendar=Calendar.getInstance();

返回日期：getDateInstance()

返回日期+时间：getDateTimeInstance()

Integer：int类型的包装类

其他包装类

byteValue() 以 byte 形式返回指定的数值。

double doubleValue() 以 double 形式返回指定的数值。

float floatValue() 以 float 形式返回指定的数值。

int intValue() 以 int 形式返回指定的数值。

long longValue() 以 long 形式返回指定的数值。

short shortValue() 以 short 形式返回指定的数值。

抽象类不能被实例化，可以用向上转型

可以有0~多个抽象方法

非抽象类必须重写父类的所有抽象方法

抽象类中没有抽象构造方法和抽象静态方法。

抽象类中可以有非抽象的构造方法，且创建对象的时候可以调用。

抽象方法没有方法体

抽象方法必须在抽象类里

抽象方法必须在子类中被实现，除非子类也是抽象类

抽象方法不能有方法体，普通方法有方法体。

抽象方法需要使用abstract修饰，接口中可以省略，普通方法没有。

抽象方法必须存在于抽象类或者接口中。

如果抽象类中的所有方法都是抽象方法，可以用接口来表示。

定义接口

接口的多继承

实现接口

1.可以被多继承
2.设计和实现完全分离
3.更自然的使用多态
4.更容易搭建程序框架
5.更容易更换实现
   。。。

1，有些接口只有名称
2，方法的实现，要通过注释约定一下，由实现类来做具体效果

List接口

Set接口

HashMap类

TreeMap类

HashTable类

例子：
for (String string : list2)
    System.out.print(string + " ");

Iterator关键字

在泛型接口、泛型类和泛型方法的定义过程中添加泛型通配符

例子：
interface Inter<T> {
     void show(T t);
}
class InterImpl<T> implements Inter<T> {
     public void show(T t) {
          System.out.println("show :"+t);
     }
}

例子：
class Point<T>{ // 此处可以随便写标识符号，T是type的简称
    private T var ; // var的类型由T指定，即：由外部指定
    public T getVar(){ // 返回值的类型由外部决定
       return var ;
    }
    public void setVar(T var){ // 设置的类型也由外部决定
       this.var = var ;
    }
};

表示不确定的java类型

例子：
A a = new A();
a.getClass()==A.getClass()
A是一个A类型，a对象也是一个A类型

程序本身无法恢复的严重错误

由Java应用程序抛出和处理的非严重错误

在方法中不处理任何的异常，而交给被调用处处理。可在方法声明出使用throws声明异常

throws声明抛出异常以通知调用者，可以声明多个异常用逗号隔开。

异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出

try-catch-fainlly

异常出现在那一行

告诉垃圾回收器该收垃圾了

垃圾回收器强制回收回收垃圾

将整个虚拟机的内容都停掉，也就是说连JVM都关闭了，内存里根本不可能还有什么东西

正常退出程序

非正常退出程序

添加log4日志的步骤

System.out.println("相对路径: " + f1.getPath());
System.out.println("文件名或目录名: " + f1.getName());
System.out.println("绝对路径: " + f1.getAbsolutePath());
System.out.println("返回父路径名，没有则返回Null: " + f1.getParent());
System.out.println("测试文件是否存在：" + (f1.exists() ? "exists" : "does not exist"));
System.out.println("测试文件是否可以修改：" + (f1.canWrite() ? "is writeable" : "is not writeable"));
System.out.println("是否可以读取"+(f1.canRead() ? "is readable" : "is not readable"));
System.out.println("测试文件名是否是目录 " + (f1.isDirectory() ? "" : "not" + " a directory"));
System.out.println("测试文件名是否是标准文件 "+(f1.isFile() ? "is normal file" : "might be a named pipe"));
System.out.println("测试文件名是否是绝对路径 "+(f1.isAbsolute() ? "is absolute" : "is not absolute"));
System.out.println("文件最后一次被修改的时间: " + f1.lastModified());
System.out.println("文件的长度: " + f1.length() + " Bytes");

详解

实体流：实体流可以直接处理数据源
装饰流：装饰流不能直接处理数据源，需要与其他装饰流或者实体流共同使用

字符流

字节流

字符流符号

线程和进程的区别：