Java基础 笔记（2）

抽象类:
abstract修饰的类，抽象类中可以有抽象方法，也可以有非抽象方法。
抽象类不能实例化对象。
如果子类继承了抽象类，必须实现抽象类中所有的抽象方法。
抽象方法必须在抽象类中。
1 抽象类一定是父类吗？ 不一定是父类，可以继承其他类或实现接口
2 抽象类可以有构造方法吗？有，用于子类对象的初始化
3 有抽象方法的类一定是抽象类吗？一定
4 抽象类中一定有抽象方法吗？不一定
5 抽象方法不可以和哪些关键字同时使用？
final：抽象类必须有子类，被final修饰的类不能有子类
static：抽象方法不能被调用，静态方法通过类名调用
private：抽象方法必须是可以被子类重写的，私有方法不能被重写

---

接口 interface：
interface 接口名{
抽象方法（public abstract）
全局常量（public static final）
}

接口：interface 规范接口可以解决单继承的问题。接口支持多继承。子类实现接口是，必须重写接口中的抽象方法。创建子类对象时，调用子类重写的方法。接口好处：    1 规范    2 提高程序可扩展性    3 降低类之间的依赖关系

通过继承可以得到该继承体系的基本功能
实现接口可以得到该继承体系之外的额外的功能

---

多态：
向上转型：父类 对象名 = new 子类（）；
向下转型：子类 对象名 = （子类）父类对象；
前提条件：向上是向下的前提，需要强转
可能会抛出异常：.ClassCastException
解决：判断
if（对象 instanceof 类名）{}

多态中成员的特点：
成员变量：编译时能访问哪些变量看父类，执行结果看父类
成员函数：编译时期能访问哪些方法看父类，执行结果看子类（前提子类重写父 类的方法,没有重写还是看父类）
静态成员函数：编译执行都看父类

---

Object类：所有类的父类
String toString（）：Object的类名@16进制哈希码
int hashCode():哈希码 —set集合
boolean equals():比较地址==，如果比较对象需要重写
Class getClass():获得类名—–反射
拥有的基本方法：
clone():返回该对象的一个副本
equals(Object obj)：判断两个对象是否相等（默认比较的是对象引用而不是值）
finalize() 当GC确定不存在对该对象的更多引用时，调用此方法
getClass() 返回该对象运行时类
hashCode() 返回哈希码
notify() 唤醒在该对象监视器上等待的单个线程
notifyAll() 唤醒在该对象监视器上等待的所有线程
toString() 返回该对象的字符串表达（默认是：Object的类名@16进制哈希码）
wait() 让一个线程等待
wait(long timeout) 等待一定时间

---

模板模式：
定义一个功能时，功能的一部分是确定的，而另一部分不确定。
确定的部分需要用到不确定的部分。
把不确定的部分暴露出去，让子类实现

    abstract class  类名{        //确定部分        public void f(){            f1();        }        //不确定部分        public abstract void f1();    }

实例:
public class TempletModel {

public static void main(String[] args) {    SuperMan spiderMan = new SpiderMan();    SuperMan ironMan = new IronMan();    spiderMan.saveWorld();    ironMan.saveWorld();}

}
abstract class SuperMan {
public void saveWorld() {
save();//第一步
overCome();//第二步
}
abstract public void save();
abstract public void overCome();
}
class SpiderMan extends SuperMan {
@Override
public void save() {
System.out.println(“我是蜘蛛侠，我在拯救世界”);
}
@Override
public void overCome() {
System.out.println(“我是蜘蛛侠，我把世界拯救了”);
}
}
class IronMan extends SuperMan {
@Override
public void save() {
System.out.println(“我是钢铁侠，我在拯救世界”);
}
@Override
public void overCome() {
System.out.println(“我是钢铁侠，我把世界拯救了”);
}
}
调用：IronMan spiderMan = new SpiderMan();
spiderMan.saveWorld();

---

内部类：
成员内部类： 内部类处在了外部类成员的位置上，所以内部类可以直接
访问外部类的成员
静态内部类： 构建器的使用（Builder）
局部内部类
匿名内部类

特点： 内部类可以直接访问外部类成员        外部类要访问内部类的成员，必须建立内部类的对象作用：    1 隐藏部分信息    2 可以访问外部类的私有成员    3 弥补了单继承的局限性    4 解决问题：如果要描述一个事物中还包括另一个事物，        同时这个事物要访问被描述的事物生成字节码文件：外部类$内部类.class一  成员内部类：内部类处在了外部类成员的位置上，所以内部类可以直接    访问外部类的成员[public/default]class 外部类{    属性    方法    内部类：    [访问修饰符] class 内部类{ //public private default protected        属性        方法    }}说明：1 内部类可以直接调用外部类的成员，包括private2 如果内部类与外部类的属性或者方法同名时，则内部类默认调用内部类自己的。    如果想调用外部类的        外部类.this.成员3 创建内部类对象    1)        外部类 外部类对象 = new 外部类（）；        外部类.内部类 内部类对象 = 外部类对象.new 内部类（）；    2)        外部类.内部类 内部类对象 = new 外部类（）.new 内部类（）;4 如果外部类想调用内部类成员，需要通过创建内部类对象来调用。5 编译之后生成的内部类字节码文件为：外部类$内部类.class

实例：

class Outer1
{
private int num = 5;
class Inner1 //成员内部类
{
int num = 500;
public void show(){
System.out.println(“inner–>num=”+num);
System.out.println(“outer–>num=”+Outer1.this.num);
}
}

public void test(){  //外部类的方法    Inner1 in = new Inner1();//外部类访问内部类成员，需要通过对象访问    in.show();}

}

---

二 静态内部类:相当于外部类，因为static修饰在初始化外部类时就已经被加载到内存中了
[public|default] class 外部类{
属性
方法
//静态内部类
[访问修饰符] static class 内部类{
属性
方法
}
}
注意：
1 不能调用外部类非静态成员
2 允许定义非静态的变量和方法
3 内部类中不能使用 外部类.this
4 静态内部类使用的格式（不依赖于外部类对象）
外部类.内部类 内部类对象 = new 外部类.内部类（）；
实例：
class Outer2
{
static int num = 10;
static class Inner2 //静态内部类
{
public static void show(){
System.out.println(“num=”+num);
}
}
public void test(){
//Inner2.show();
Inner2 in = new Inner2();
in.show();
}
}

---

三 局部内部类：定义在方法的内部
[public|default] class 外部类{
属性
方法（）{
class 内部类{

        }    }}应用：多线程、网络下载注意：1 局部内部类或者局部方法的访问修饰符只能是default的2 局部内部类可以访问外部类成员3 局部内部类如果想使用所在方法的局部变量时，该变量必须是final的（因为final存在于方法区，生命周期较长，不      影响局部内部类的使用）4 局部内部类定义在方法中，适用范围仅在方法内

实例：
class Outer3
{
int a = 5;
void test(){
final int b = 100;
class Inner3
{
public void show(){
System.out.println(“外部类成员a=”+a);
System.out.println(“方法中的成员b=”+b);
}
}//end class
Inner3 in = new Inner3();
in.show();
}//end test()
}

---

匿名内部类：内部类的简写，没有类名
只使用一次对象时，才会定义匿名内部类

前提：匿名内部类必须继承或者实现一个外部类或者接口

应用：应用于抽象类和接口，增加程序的灵活性

语法：
类名 对象名 = new 类名(){ //抽象类或者接口的名字
将抽象类或者接口的方法实现
};