java基础知识学习笔记2

    1.面向对象的三大特点：

（1）封装；a.将属性和方法放在独立的类中，使之成为独立的代码单元；

b.通过权限修饰符（private、public、protected等）实现对类内部信息的隐藏或公开，提供尽量少的方法访问或修改类内部的信息；

（2）继承；子类extends父类，将拥有父类的除private修饰方法和属性（同一包中）；java只支持单继承，即一个子类只有一个父类；

（3）多态；包括继承、接口、重载等等‘

    2.方法重载overloaded和覆盖overriden；

overloaded：（1）重载时只能通过不同的参数完成，如不同的参数类型，不同的参数个数，不同的参数顺序；

（2）不能通过访问权限、返回类型、抛出的异常进行重载；

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

（4）不能在子类对父类中的private方法重载。

overridden:(1) 子类的方法名、参数个数、参数类型必须和父类中所覆盖的方法完全相同；

(2) 子类的方法返回类型必须和所覆盖的方法相同；

(3) 子类方法不能缩小所覆盖方法的访问权限；

(4) 子类方法不能抛出比所覆盖方法更多的异常；

3.this和super；

this：是指当前对象， 用法： （1）调用本类中的属性，也可以作为参数传递，eg.：this.xxx。

（2）调用本类中的其他方法，如this(a,b)；

（3）调用本类中的其他构造方法，调用时要放在构造方法的首行。

super:是指父类对象；用法:（1）调用父类的属性和方法，super.xxx/super.ff();

（2）调用父类的构造方法，只能放在当前构造方法的首行；

    4.final和static：

final：（1）修饰变量则改变量为常量。final MAC=100；

（2）修饰方法则该方法不能被重写，修饰类则该类不能被继承；

static：（1）修饰变量则改变量为静态变量，即此类的实例共享此变量，它不为任何实例所有，只分配一次内存地址，调用“类名.变量”；

（2）修饰方法则该方法不需要实例对象就可调用，调用“类名.方法”。

（3）一般普通类不允许声明为静态的，只有内部类才可以，此时这个内部类作为一个普通类来使用，而不需实例一个外部类。

（4）static block：形式static｛...｝，静态代码块在类被加载时就执行，且只被执行一次，可用来类属性的初始化；

    5.finalize（）方法和Ststem.gc（）方法：

finalize（）：在从堆中永久删除对象之前，垃圾回收器调用该对象的Finalize方法。注意，无法确切地保证垃圾回收器何时调用该方法，

也无法保证调用不同对象的方法的顺序。

System.gc（）：垃圾回收机制。

    6.单态设计模式：保证在整个系统中只存在某个类的一个实例对象。类的构造方法必须声明为private，即防止外部new新的实例对象；提供一个返回唯一实例对象的方法getInstance（）；

e.g.：public class  Singleton{

              private static final Singleton s = new Singleton()；

              private Singleton(){}

              public Singleton getIntance(){

                    return s;

              }

        }

     7.内部类InnerClass：成员内部类、局部内部类、静态内部类和匿名内部类。

（1）成员内部类；作为外部类的一个成员存在，与外部类的属性、方法并列，成员内部类中不能定义静态变量,但可以访问外部类的所有成员。访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。

（2）局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。

局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。

（3）静态内部类： 静态内部类定义在类中，任何方法外，用static定义，成为了普通类。

（4）匿名内部类 ：一种特殊的局部内部类，只是为了获得一个对象实例，不需要知道其实际类型。

8.抽象类和接口

（1）抽象类：由关键字abstract修饰的类，包含abstract修饰的方法，即含有方法定义没有具体实现方法的类，也可以包含实现的方法；

继承抽象类的子类必须实现父类的抽象方法；

public abstract class Ex{

abstract void ff();

void ff1();

}

（2）接口interface:一系列方法定义的集合，它不提供实现接口的具体代码，只提供一系列方法的定义，它所包含的方法都是public

abstract修饰的方法（可省略不写）；接口中定义的变量是final static修饰的；接口没有构造方法；类与接口之间的代码复用关系叫实现，

一个类可以实现多个接口。

interface Runnable｛

void run();

｝

class Fish implements Runnable{

public void run()

{ System.out.println("The fish is swimming!");}

}

class Bird{

public void run implements Runnable()

{ System.out.println("The bird is flying!");}

}

接口回调技术：

Runnable r1=new Fish();

ri.run();//接口回调

接口编程的好处：尽量降低系统的耦合度；将标准的制定者和实现者分离；接口尽量简单、单一；

9.线程：进程在执行过程中的一条执行线索；

创建线程的两种方法：(1)继承Thread类；class T extends Thread{} new T().start();

(2)实现Rnnable，调用Thread类的构造方法；

class T implements Runn｛public void run（）｛...｝｝ new Thread(new T()).start();

实现线程同步的两种方法：

（1）Synchronized代码块；

class A{}

class Adder(){ A a；synchronied(a)｛...｝}

class Getter(){A a；synchronied(a)｛...｝}

（2）Synchronized类；

class A { public synchronized void add(){}  public synchronized void get(){}}

class Adder implements Runnable{ private A a; public Adder(A a){this.a=a;}public void run(){q.add()}}//添加数据

class Getter implements Runnable{ private A a; public Getter(A a){this.a=a;}public void run(){q.get()}}//读取数据

public class Test{public static void main(){A a=new A();}new Thread(new Adder(a)).start() ;

new Thread(new Getter(a)).start() ;

}

10.异常Exception"程序在运行的时候肯能出现的非致命性错误，程序提供了处理这些错误的方法；

try{}cath(Exception e){}finally{}；try部分放置可能出现异常的语句，cath负责捕获异常并作出相应的处理，finally部分是否抛出异

常都会执行；

throw：手动地抛出异常对象；throws声明方法可能回避的异常，即抛出异常后，必须处理，如果不想处理，就通过throws把异常往上传

递给上层处理；