java-5-面向对象

[TOC]

java面向对象

关键字static：

static 使用环境

创造由类可以直接使用的关键字：

class Circle{
    private double radius;
    public Circle(double radius){
        this.radius=radius;
		}
    public double findArea(){
        return Math.PI*radius*radius;
		}
}

• 创建两个Circle对象

  Circle c1=new Circle(2.0); //c1.radius=2.0
  Circle c2=new Circle(3.0); //c2.radius=3.0

• Circle类中的变量radius是一个实例变量(instance variable)， 它属于类的每一个对象， 不能被同一个类的不同对象所共享。

• 上例中c1的radius独立于c2的radius， 存储在不同的空间。 c1中的radius变化不会影响c2的radius， 反之亦然。

==如果想让一个类的所有实例共享数据，就用类变量！==

• 类属性作为该类各个对象之间共享的变量。 在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
• 如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

使用范围：

• 在Java类中， 可用static修饰属性、 方法、 代码块、 内部类

• 被修饰后的成员具备以下特点：

  • 随着类的加载而加载
  • 优先于对象存在
  • 修饰的成员，被所有对象所共享
  • 访问权限允许时，可不创建对象，直接被类调用

实例1

class Circle {
        private double radius;
        public static String name = "这是一个圆";
        public static String getName() {
        return name;
    }
        public Circle(double radius) {
        this.radius = radius;
    }
        public double findArea() {
        return Math.PI * radius * radius;
    }
        public void display() {
        System.out.println("name:" + name + "radius:" + radius);
    }
}

public class StaticTest {
        public static void main(String[] args) {
        Circle c1 = new Circle(2.0);
        Circle c2 = new Circle(3.0);
        c1.display();
        c2.display();
    }
}

实例2

class Person { 类变量应用举例
        private int id;
        public static int total = 0;
        public Person() {
            total++;
            id = total;
    }
        public static void main(String args[]){
            Person Tom=new Person();
            Tom.id=0;
            total=100; // 不用创建对象就可以访问静态成员
    }
}

public class StaticDemo {
    public static void main(String args[]) {
        Person.total = 100; // 不用创建对象就可以访问静态成员
        //访问方式：类名.类属性， 类名.类方法
        System.out.println(Person.total);
        Person c = new Person();
        System.out.println(c.total); //输出101
    }
}

类变量 vs 实例变量内存解析

class Chinese{
    String name;
    int age;
    static String nation;
}

类方法(class method)

• 没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法。
• 在static方法内部只能访问类的static修饰的属性或方法， 不能访问类的非static的结构

class Person {
    private int id;
    private static int total = 0;
    public static int getTotalPerson() {
        //id++; //非法
        return total;
    }
    public Person() {
        total++;
        id = total;
        }
	}
public class PersonTest {
    public static void main(String[] args) {
        System.out.println("Number of total is " + Person.getTotalPerson());
        //没有创建对象也可以访问静态方法
        Person p1 = new Person();
        System.out.println( "Number of total is "+ Person.getTotalPerson());
    }
}

//The output is:
//Number of total is 0
//Number of total is 1

• ==因为不需要实例就可以访问static方法，因此static方法内部不能有this。 (也不能有super ? YES!)==
• ==static修饰的方法不能被重写==

class Person {
    private int id;
    private static int total = 0;
    public static void setTotalPerson(int total){
    	this.total=total; //非法，在static方法中不能有this，也不能有super
    }
    public Person() {
        total++;
        id = total;
   		}
	}
    public class PersonTest {
        public static void main(String[] args) {
        Person.setTotalPerson(3);
    } 
}

static 应用-单例 (Singleton)设计模式

• 设计模式是==在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式==。 设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱==。 ”套路==”
• 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类==只能存在一个对象实例==，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将==类的构造器的访问权限设置为private==，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用==该类的某个静态方法==以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的==该类对象的变量也必须定义成静态的==。

单例(Singleton)设计模式-饿汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
    	return single;
    }
}

单例(Singleton)设计模式-懒汉式

class Singleton {
// 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
        single = new Singleton();
    	}
    	return single;
    }
}

==懒汉式暂时还存在线程安全问题，讲到多线程时，可修复== 。

单例模式的优点

• 由于单例模式只生成一个实例， 减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

单例(Singleton)设计模式-应用场景

1. 网站的计数器，一般也是单例模式实现，否则难以同步。
2. 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作， 否则内容不好追加。
3. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
4. 项目中， 读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
5. Application 也是单例的典型应用
6. Windows的Task Manager (任务管理器)就是很典型的单例模式
7. Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例

main方法

使用方法

• 由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public， 又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。
• 又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到

public class CommandPara {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

//运行程序CommandPara.java
// $ java CommandPara “Tom" “Jerry" “Shkstart"
/**
输出结果：
args[0] = Tom
args[1] = Jerry
args[2] = Shkstart
*/

// 此处， Something类的文件名叫OtherThing.java
class Something {
public static void main(String[] something_to_do) {
System.out.println("Do something ...");
	}
}
//上述程序是否可以正常编译、运行？
// 编译可以通过，运行也可以通过

注：

1. Java保存的文件名必须与类名一致；
2. 如果文件中只有一个类，文件名必须与类名一致；
3. 一个Java文件中只能有一个public类；
4. 如果文件中不止一个类，文件名必须与public类名一致；
5. 如果文件中不止一个类，而且没有public类，文件名可与任一类名一致。

​ 当编写一个Java源代码文件时，此文件通常被称为编译单元（有时也称为转译单元）。每个编译单元都必须要有一个后缀为.java，而在编译单元内则可以 有一个public类，该类的名称必须与文件名称相同(包括大小写，但不包括文件的后缀名.java)。每个编译单元只能有一个public类，否则编译 器就不会接受。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，这是因为他们不是public类，而且他们主要用来为主要 public类提供支持。

1. 每个编译单元（文件）都只能有一个public类。这表示，每个编译单元都有单一的公共接口，用public类来表现。该接口可以按要求包含众多的支持包访问权限的类。如果在某个编译单元内有一个以上的public类，编译器就会给出出错信息。

2. public类的名称必须完全与含有该编译单元的文件名相匹配，包括大小写。所以对于Widget而言，文件的名称必须是Widget.java，而不是widget.java或WIDGET.java。如果不匹配，同样将得到编译时错误。

3. 虽然不是很常用，但编译单元内完全不带public类也是可能的。这种情况下，可以随意对文件命名。（尽管随意命名会使得人们在阅读和维护代码时产生混淆。）

代码块

代码块(或初始化块)的作用：

• 对Java类或对象进行初始化
• 代码块(或初始化块)的分类：
  • 一个类中代码块若有修饰符， 则只能被static修饰， 称为静态代码块(static block)， 没有使用static修饰的， 为非静态代码块。
• static代码块通常用于初始化static的属性

class Person {
	public static int total;
    static {
    total = 100;//为total赋初值
    }
…… //其它属性或方法声明
} 

静态代码块：用static 修饰的代码块

1. 可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5. 静态代码块的执行要先于非静态代码块。
6. 静态代码块随着类的加载而加载，且只执行一次。

非静态代码块：没有static修饰的代码块

1. 可以有输出语句。
2. 可以对类的属性、 类的声明进行初始化操作。
3. 除了调用非静态的结构外， 还可以调用静态的变量或方法。
4. 若有多个非静态的代码块， 那么按照从上到下的顺序依次执行。
5. 每次创建对象的时候， 都会执行一次。 且先于构造器执行。

class Person {
    public static int total;
        static {
            total = 100;
            System.out.println("in static block!");
        }
    }
    public class PersonTest {
        public static void main(String[] args) {
            System.out.println("total = " + Person.total);
            System.out.println("total = " + Person.total);
    }
}
/**
输出：
in static block
total=100
total=100*/

程序中成员变量赋值的执行顺序

声明成员变量的默认初始化 —>显式初始化、 多个初始化块依次被执行（ 同级别下按先后顺序执行）—>构造器再对成员进行初始化操作—>通过” 对象.属性” 或” 对象.方法” 的方式， 可多次给属性赋值

关键字： final

定义：

• 在Java中声明类、 变量和方法时， 可使用关键字final来修饰,表示“最终的” 。
  • final标记的类不能被继承。 提高安全性， 提高程序的可读性。
    • String类、 System类、 StringBuffer类
  • final标记的方法不能被子类重写。
    • 比如： Object类中的getClass()。
  • final标记的变量(成员变量或局部变量)即称为常量。 名称大写， 且只能被赋值一次。
    • final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值， 然后才能使用。
    • final double MY_PI = 3.14;

final修饰类

final class A{
}
class B extends A{ //错误，不能被继承。
}

final修饰方法

class A {
    public final void print() {
        System.out.println("A");
        }
    }
    class B extends A {
        public void print() { // 错误，不能被重写。
        System.out.println("尚硅谷");
    }
}

final修饰变量——常量

class A {
    private final String INFO = "atguigu"; //声明常量
        public void print() {
        //The final field A.INFO cannot be assigned
        //INFO = "尚硅谷";
    }
}

// static final：全局常量

总结：

• final 用来修饰一个类:此类不能被其他类所继承。
  • 比如：String类、System类、StringBuffer类

• final 用来修饰方法：表明此方法不可以被重写
• 比如：Object类中getClass();
• final 用来修饰变量：此时的”变量”就称为是一个常量
  • final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
  • final修饰局部变量：
• 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
• static final 用来修饰属性：全局常量

关键字final应用举例

public final class Test {
    public static int totalNumber = 5;
    public final int ID;
    public Test() {
        ID = ++totalNumber; // 可在构造器中给final修饰的“变量”赋值
    }
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.ID);
        final int I = 10;
        final int J;
        J = 20;
        J = 30; // 非法
    }
}

排错：

public class Something {
    public int addOne(final int x) {
        return ++x;//x 不可变，报错
        // return x + 1;//正常运行
    }
}
//###################################
// 正常运行
public class Something {
    public static void main(String[] args) {
        Other o = new Other();
        new Something().addOne(o);
    }
    public void addOne(final Other o) {//o不可变，但o的属性是可变的
        // o = new Other();
        o.i++;
        }
    }
class Other {
    	public int i;
}

抽象类与抽象方法

​ 随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做==抽象类==。

• 用abstract关键字来修饰一个类， 这个类叫做抽象类。
• 用abstract来修饰一个方法， 该方法叫做抽象方法。
• 抽象方法：只有方法的声明，没有方法的实现。以分号结束：
  • 比如： public abstract void talk();
• 含有抽象方法的类必须被声明为抽象类。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
• ==不能用abstract修饰变量、代码块、构造器；==
• ==不能用abstract修饰私有方法、静态方法、 final的方法、 final的类。==

抽象类举例

abstract class A { //抽象类举例
    abstract void m1();
    public void m2() {
        System.out.println("A类中定义的m2方法");
        }
    }
    class B extends A {
        void m1() {
        	System.out.println("B类中定义的m1方法");
        }
    }
    public class Test {
        public static void main(String args[]) {
            A a = new B();
            a.m1();
            a.m2();
    }
}

抽象类应用

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

多态的应用：模板方法设计模式(TemplateMethod)

​ 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
解决的问题：

• 当功能内部一部分实现是确定的， 一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
• ==换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。==

abstract class Template {
    public final void getTime() {
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println("执行时间是： " + (end - start));
    	}
    public abstract void code();
    }
class SubTemplate extends Template {
    public void code() {
        for (int i = 0; i < 10000; i++) {
        	System.out.println(i);
        }
    }
}

模板方法 (TemplateMethod)

模板方法设计模式是编程中经常用得到的模式。 各个框架、 类库中都有他的影子， 比如常见的有：

• 数据库访问的封装
• Junit单元测试
• JavaWeb的Servlet中关于doGet/doPost方法调用
• Hibernate中模板程序
• Spring中JDBCTemlate、 HibernateTemplate等

abstract: 总结

• 可以用来修饰：类、方法具体的：

• abstract修饰类：抽象类

  > - 此类不能实例化
  

  • 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
  • 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 —->抽象的使用前提：继

• abstract修饰方法：抽象方法

  • 抽象方法只方法的声明，没方法体

• 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。

  • 若子类重写了父类中的所的抽象方法后，此子类方可实例化
  • 若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用ab>stract修饰

• 注意点：

  • abstract不能用来修饰：属性、构造器等结构
  • abstract不能用来修饰私方法、静态方法、final的方法、final的类

接口(interface)

定义

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。 继承是一个”是不是”的关系，而接口实现则是 “能不能”的关系。

• 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守

• 接口(interface)是抽象方法和常量值定义的集合。

• 接口的特点：

  • 用interface来定义。
  • 接口中的所有成员变量都默认是由==public static final修饰的==。
  • 接口中的所有抽象方法都默认是由==public abstract==修饰的。
  • 接口中==没有构造器==。
  • 接口采用多继承机制

public interface Runner {
    int ID = 1;
    void start();
    public void run();
    void stop();
}

public interface Runner {
    public static final int ID = 1;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

• 定义Java类的语法格式： 先写extends，后写implements

  • class SubClass extends SuperClass implements InterfaceA{ }

• 一个类可以实现多个接口， 接口也可以继承其它接口。

• 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。

• 接口的主要用途就是被实现类实现。 （面向接口编程）

• 与继承关系类似，接口与实现类之间存在多态性

• 接口和类是并列关系， 或者可以理解为一种特殊的类。 从本质上讲，接口是一种特殊的抽象类，这种抽象类

  中只包含常量和方法的定义(JDK7.0及之前)， 而没有变量和方法的实现

接口应用举例

interface Runner { 
    public void start(); //接口应用举例(2)
    public void run();
    public void stop();
    }
class Person implements Runner {
    public void start() {
        // 准备工作：弯腰、蹬腿、咬牙、瞪眼
        // 开跑
    }
    public void run() {
        // 摆动手臂
        // 维持直线方向
    }
    public void stop() {
    	// 减速直至停止、喝水。
    }
}

一个类可以实现多个无关的接口

interface Runner { public void run();}
    interface Swimmer {public double swim();}
    class Creator{public int eat(){…}}
    class Man extends Creator implements Runner ,Swimmer{
    public void run() {……}
    public double swim() {……}
    public int eat() {……}
}

与继承关系类似，接口与实现类之间存在多态性

public class Test{
    public static void main(String args[]){
    Test t = new Test();
    Man m = new Man();
        t.m1(m);
        t.m2(m);
        t.m3(m);
    }
    public String m1(Runner f) { f.run(); }
    public void m2(Swimmer s) {s.swim();}
    public void m3(Creator a) {a.eat();}
}

实现类必须实现所有父类的所有抽象方法

实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中所有方法的实现。否则， SubAdapter仍需声明为abstract的。

interface MyInterface{
    String s=“MyInterface”;
    public void absM1();
}
interface SubInterface extends MyInterface{
    public void absM2();
}
public class SubAdapter implements SubInterface{
    public void absM1(){System.out.println(“absM1”);}
    public void absM2(){System.out.println(“absM2”);}
}

接口的应用：代理模式(Proxy)

概述：代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问

interface Network {
	public void browse();
}
// 被代理类
class RealServer implements Network {
    @Override
    public void browse() {
        System.out.println("真实服务器上网浏览信息");
    }
}
class ProxyServer implements Network {
    private Network network;
    public ProxyServer(Network network) {
    	this.network = network;
    }
    public void check() {
    	System.out.println("检查网络连接等操作");
    }
    public void browse() {
        check();
        network.browse();
    }
}
public class ProxyDemo {
    public static void main(String[] args) {
        Network net = new ProxyServer(new RealServer());
        net.browse();
    }
}

应用场景：

全代理： 屏蔽对真实角色的直接访问。
远程代理： 通过代理类处理远程方法调用（RMI）
延迟加载： 先加载轻量级的代理对象， 真正需要再加载真实对象

比如你要开发一个大文档查看软件， 大文档中有大的图片， 有可能一个图片有100MB， 在打开文件时， 不可能将所有的图片都显示出来， 这样就可以使用代理模式， 当需要查看图片时， 用proxy来进行大图片的打开。

• 分类

  静态代理（静态定义代理类）
  动态代理（动态生成代理类）
  JDK自带的动态代理， 需要反射等知识

接口和抽象类之间的对比

No.	区别点	抽象类	接口
1	定义	包含抽象方法的类	主要是抽象方法和全局常量的集合
2	组成	构造方法、抽象方法、普通方法、 常量、变量	常量、抽象方法、 (jdk8.0:默认方法、静态方法)
3	使用	子类继承抽象类(extends)	子类实现接口(implements)
4	关系	抽象类可以实现多个接口	接口不能继承抽象类，但允许继承多个接口
5	常见设计模式	模板方法	简单工厂、工厂方法、代理模式
6	对象	都通过对象的多态性产生实例化对象
7	局限	抽象类有单继承的局限	接口没有此局限
8	实际	作为一个模板	是作为一个标准或是表示一种能力
9	选择	如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限

==在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口==

排错：

interface A {
    int x = 0;
}
class B {
	int x = 1;
}
class C extends B implements A {
    public void pX() {
    	System.out.println(x); //编译报错
        System.out.println(this.x);// 1
        System.out.println(A.x);//0
        //如果父类和实现类没有同名，则不会错
		}
	public static void main(String[] args) {
    	new C().pX();//类优先
   	 	}
}

interface Playable {
	void play();
}
interface Bounceable {
	void play();
}
interface Rollable extends Playable, Bounceable {
    	Ball ball = new Ball("PingPang");  // 
}

class Ball implements Rollable {
    private String name;
        public String getName() {
        	return name;
    }
    public Ball(String name) {
    	this.name = name;
    }
    public void play() {  // 有重名都重写
   		ball = new Ball("Football"); //ball 是 final 的不能被重定义
    	System.out.println(ball.getName());
    }
}

Java 8中关于接口的改进

1. Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。
2. 静态方法： 使用 static 关键字修饰。 可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。
3. 默认方法： 默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如： java 8 API中对Collection、 List、 Comparator等接口提供了丰富的默认方法。

public interface AA {
    double PI = 3.14;
    public default void method() {
    	System.out.println("北京");
    }
    default String method1() {
    	return "上海";
    }
    public static void method2() {
    	System.out.println(“hello lambda!");
    }
}

接口中的默认方法

• 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现： ==接口冲突==。

• 解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。

• 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守： ==类优先原则==。 接口中具有相同名称和参数的默认方法会被忽略。

interface Filial {// 孝顺的
	default void help() {
    	System.out.println("老妈，我来救你了");
    }
}
interface Spoony {// 痴情的
    default void help() {
        System.out.println("媳妇， 别怕，我来了");
    }
}
class Man implements Filial, Spoony {
    @Override
    public void help() {
        System.out.println("我该怎么办呢？ ");
        Filial.super.help();
        Spoony.super.help();
    }
}

内部类

定义：

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
• 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
• Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
  • Inner class的名字不能与包含它的外部类类名相同；
• 分类： 成员内部类（static成员内部类和非static成员内部类）

           **局部内部类**（不谈修饰符）、匿名内部类 
  

成员内部类

• 成员内部类作为类的成员的角色：

  1. 和外部类不同， Inner class还可以声明为private或protected；
  2. 可以调用外部类的结构
  3. Inner class 可以声明为static的， 但此时就不能再使用外层类的非static的成员变量；

• 成员内部类作为类的角色：

  1. 可以在内部定义属性、 方法、 构造器等结构
  2. 可以声明为abstract类 ， 因此可以被其它的内部类继承
  3. 可以声明为final的
  4. 编译以后生成OuterClass$InnerClass.class字节码文件（ 也适用于局部内部类）

• 【注意】

  1. 非static的成员内部类中的成员不能声明为static的， 只有在外部类或static的成员内部类中才可声明static成员。
  2. 外部类访问成员内部类的成员， 需要“内部类.成员”或“内部类对象.成员”的方式
  3. 成员内部类可以直接使用外部类的所有成员， 包括私有的数据
  4. 当想要在外部类的静态成员部分使用内部类时， 可以考虑内部类声明为静态的

class Outer {
    private int s;
    public class Inner {
        public void mb() {
            s = 100;
            System.out.println("在内部类Inner中s=" + s);
        }
    }
    public void ma() {
            Inner i = new Inner();
            i.mb();
        }
    }
    public class InnerTest {
        public static void main(String args[]) {
            Outer o = new Outer();
            o.ma();
    }
}

如何在成员内部类中调用外部类的结构？

public class Outer {
    private int s = 111;
    public class Inner {
        private int s = 222;
        public void mb(int s) {
            System.out.println(s); // 局部变量s
            System.out.println(this.s); // 内部类对象的属性s
            System.out.println(Outer.this.s); // 外部类对象属性s
        }
    }
    public static void main(String args[]) {
        Outer a = new Outer();
        //Outer.Inner b = new Outer.Inner();
        Outer.Inner b = a.new Inner();
        b.mb(333);
    }
}

局部内部类

class 外部类{
    方法(){
        class 局部内部类{
        }
    }
    {
        class 局部内部类{
        }
    }
}

• 如何使用局部内部类

  • 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
  • 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

• 局部内部类的特点

  1. 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
  2. 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
  3. 局部内部类可以使用外部类的成员，包括私有的。
  4. 局部内部类可以==使用外部方法的局部变量==，==但是必须是final的==。 由局部内部类和局部变量的声明周期不同所致。
  5. 局部内部类和局部变量地位类似，==不能使用public,protected,缺省,private==
  6. 局部内部类==不能使用static修饰，因此也不能包含静态成员==

• jdk 7及之前版本：要求此局部变量显式的声明为final的

• jdk 8及之后的版本：可以省略final的声明
• 总结：
  • 成员内部类和局部内部类，在编译以后，都会生成字节码文件。
  • 格式：成员内部类：外部类\$内部类名.class

      局部内部类：外部类​\$数字 内部类名.class
    

匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

• 格式：

  new 父类构造器（实参列表） |实现接口(){
  	//匿名内部类的类体部分
  }

• 匿名内部类的特点

  • 匿名内部类必须继承父类或实现接口
  • 匿名内部类只能有一个对象
  • 匿名内部类对象只能使用多态形式引用

interface A{
	public abstract void fun1();
}
public class Outer{
    public static void main(String[] args) {
        new Outer().callInner(new A(){
            //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名
            public void fun1() {
                System.out.println(“implement for fun1");
            }
        });// 两步写成一步了
    }
    public void callInner(A a) {
    	a.fun1();
    }
}

public class Test {
    public Test() {
        Inner s1 = new Inner();
        s1.a = 10;
        Inner s2 = new Inner();
        s2.a = 20;
        Test.Inner s3 = new Test.Inner();
        System.out.println(s3.a);//5
    }
    class Inner {
   		public int a = 5;
    }
    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();
        System.out.println(r.a);//5
    }
}

异常概述与异常体系结构

概念

• 异常：在Java语言中， 将程序执行中发生的不正常情况称为“异常” 。(开发过程中的语法错误和逻辑错误不是异常)

  • Java程序在执行过程中所发生的异常事件可分为两类：

    • Error： Java虚拟机无法解决的严重问题。 如： JVM系统内部错误、 资源耗尽等严重情况。 比如： StackOverflowError和OOM。 一般不编写针对性的代码进行处理。

    • Exception: 其它因编程错误或偶然的外在因素导致的一般性问题， 可以使用针对性的代码进行处理。 例如：

      • 空指针访问
      • 试图读取不存在的文件
      • 网络连接中断
      • 数组角标越界

• 对于==这些错误， 一般有两种解决方法==：一是遇到错误就终止程序的运行。 另一种方法是由程序员在编写程序时， 就考虑到错误的检测、 错误消息的提示， 以及错误的处理。

• 捕获错误最理想的是在编译期间， 但有的错误只有在运行时才会发生。比如： 除数为0， 数组下标越界等

  • 分类： 编译时异常和运行时异常

异常分类

• 编译时异常：执行javac.exe命名时，可能出现的异常

  • 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。 编译器要求Java程序必须捕获或声明所有编译时异常。
  • 对于这类异常，如果程序不处理，可能会带来意想不到的结果。

• 运行时异常：执行java.exe命名时，出现的异常

  • 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。 java.lang.RuntimeException类及它的子类都是运行时异常。
  • 对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

//几种常见的异常

public class IndexOutExp {
    public static void main(String[] args) {
    String friends[] = { "lisa", "bily", "kessy" };
    for (int i = 0; i < 5; i++) {
    System.out.println(friends[i]); // friends[4]?
    }
    System.out.println("\nthis is the end");
    }
}
/**
程序IndexOutExp.java编译正确，运行结果： java IndexOutExp
lisa
bily
kessy
java.lang.ArrayIndexOutOfBoundsException
at Test7_1.main(Test7_1.java:5)
Exception in thread "main
*/
public class NullRef {
    int i = 1;
    public static void main(String[] args) {
        NullRef t = new NullRef();
        t = null;
        System.out.println(t.i);
    }
}
/**
程序NullRef.java编译正确，运行结果： java NullRef
    java.lang.NullPointerException
    at NullRef.main(NullRef.java:6)
    Exception in thread "main
*/

public class DivideZero {
    int x;
    public static void main(String[] args) {
        int y;
        DivideZero c=new DivideZero();
        y=3/c.x;
        System.out.println("program ends ok!");
    }
}

/**
程序DivideZero.java编译正确，运行结果： java DivideZero
java.lang.ArithmeticException: / by zero
at DivideZero.main(DivideZero.java:6)
Exception in thread "main"
*/

public class Order {
    public static void main(String[] args) {
        Object obj = new Date();
        Order order;
        order = (Order) obj;
        System.out.println(order);
    }
}
/**
程序Person.java编译正确，运行结果： java Person
java.lang. java.lang.ClassCastException
at Person.main(Person.java:5)
Exception in thread "main"
*/

异常处理机制一：try-catch-finally

• Java提供的是异常处理的抓抛模型。
• Java程序的执行过程中如出现异常， 会生成一个异常类对象，该异常对象将被提交给Java运行时系统， 这个过程称为抛出(throw)异常。
• 异常对象的生成
  由虚拟机==自动生成==：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出

• 由开发人员==手动创建==：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样

• 如果一个方法内抛出异常， 该异常对象会被抛给调用者方法中处理。 如果异常没有在调用者方法中处理， 它继续被抛给这个调用方法的上层方法。 这个过程将一直继续下去， 直到异常被处理。这一过程称为捕获(catch)异常。

• 如果一个异常回到main()方法， 并且main()也不处理， 则程序运行终止。
• 程序员通常只能处理Exception， 而对Error无能为力。

try{
    ...... //可能产生异常的代码
    }
    catch( ExceptionName1 e ){
    ...... //当产生ExceptionName1型异常时的处置措施
    }
    catch( ExceptionName2 e ){
    ...... //当产生ExceptionName2型异常时的处置措施
    } 
    [
    finally{
    ...... //无论是否发生异常， 都无条件执行的语句
    } ]

/*
try{
 * 		//可能出现异常的代码
 * 
 * }catch(异常类型1 变量名1){
 * 		//处理异常的方式1
 * }catch(异常类型2 变量名2){
 * 		//处理异常的方式2
 * }catch(异常类型3 变量名3){
 * 		//处理异常的方式3
 * }
 * ....
 * finally{
 * 		//一定会执行的代码
 * }*/

• try
  捕获异常的第一步是用try{…}语句块选定捕获异常的范围， 将可能出现异常的代码放在try语句块中。

• catch (Exceptiontype e)
  在catch语句块中是对异常对象进行处理的代码。 每个try语句块可以伴随一个或多个catch语句， 用于处理可能产生的不同类型的异常对象

• 如果明确知道产生的是何种异常， 可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。
• 比 如 ： 可 以 用 ArithmeticException 类 作 为 参 数 的 地 方 ， 就 可 以 用RuntimeException类作为参数， 或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常， 如NullPointerException（ catch中的语句将不会执行） 。

• 捕获异常的有关信息：
  与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

  • getMessage() 获取异常信息，返回字符串
  • printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

• finally

  • 捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
  • ==不论在try代码块中是否发生了异常事件， catch语句是否执行， catch语句是否有异常， catch语句中是否有return，finally块中的语句都会被执行。==
  • finally语句和catch语句是任选的

实例；

public class IndexOutExp {
    public static void main(String[] args) {
        String friends[] = { "lisa", "bily", "kessy" };
        try {
            for (int i = 0; i < 5; i++) {
            	System.out.println(friends[i]);
        		}
        }catch (ArrayIndexOutOfBoundsException e) {
        	System.out.println("index err");
        }
        System.out.println("\nthis is the end");
    }
}

/*程序IndexOutExp.java运行结果： java IndexOutExp
lisa
bily
kessy
index err
this is the end*/

public class DivideZero1 {
    int x;
    public static void main(String[] args) {
        int y;
        DivideZero1 c = new DivideZero1();
        try {
        	y = 3 / c.x;
        } catch (ArithmeticException e) {
        	System.out.println("divide by zero error!");
        }
        System.out.println("program ends ok!");
    }
}

/**
程序DivideZero1运行结果： java DivideZero1
divide by zero error!
program ends ok!
**/

不捕获异常时的情况

• 前面使用的异常都是RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获， Java自己也能捕获，并且编译通过( 但运行时会发生异常使得程序运行终止 )。
• 如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常

import java.io.*;
    public class IOExp {
        public static void main(String[] args) {
            FileInputStream in = new FileInputStream("atguigushk.txt");
            int b;
            b = in.read();
        while (b != -1) {
            System.out.print((char) b);
            b = in.read();
        }
        in.close();
    }
}

import java.io.*;
public class IOExp {
    public static void main(String[] args) {
        try {
            FileInputStream in = new FileInputStream("atguigushk.txt");
            int b;
            b = in.read();
        while (b != -1) {
            System.out.print((char) b);
            b = in.read();
        }
        	in.close();
        } catch (IOException e) {
        	System.out.println(e);
        } finally {
        	System.out.println(" It’s ok!");
        }
    }
}

总结：

1. finally是可以写可以不写的。
2. 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3. 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没写finally的情况。继续执行其后的代码
4. catch中的异常类型如果没子父类关系，则谁声明在上，谁声明在下无所谓。
   catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
5. 常用的异常对象处理的方式： ① String getMessage() ② printStackTrace()
6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用
7. try-catch-finally结构可以嵌套
   总结：如何看待代码中的编译时异常和运行时异常？

体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当 于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对 于编译时异常，我们说一定要考虑异常的处理。

finally的再说明：

1. finally是可的
2. finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中return语句，catch中return语句等情况。
3. 像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

异常处理机制二：throws

• ==声明抛出异常==是Java中处理异常的第二种方式

  • 如果一个方法(中的语句执行时)可能生成某种异常， 但是并不能确定如何处理这种异常， 则此方法应显示地声明抛出异常， 表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
  • 在方法声明中用throws语句可以声明抛出异常的列表， throws后面的异常类型可以是方法中产生的异常类型， 也可以是它的父类。

  “throws + 异常类型”写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！

• 声明抛出异常举例：

public void readFile(String file) throws FileNotFoundException {
    ……
    // 读文件的操作可能产生FileNotFoundException类型的异常
    FileInputStream fis = new FileInputStream(file);
    ..……
} 

import java.io.*;
public class ThrowsTest {
    public static void main(String[] args) {
        ThrowsTest t = new ThrowsTest();
        try {
        	t.readFile();
        } catch (IOException e) {
        	e.printStackTrace();
        }
    }
    public void readFile() throws IOException {
        FileInputStream in = new FileInputStream("atguigushk.txt");
        int b;
        b = in.read();
        while (b != -1) {
            System.out.print((char) b);
            b = in.read();
        }
        in.close();
    }
}

• 重写方法不能抛出比被重写方法范围更大的异常类型。 在多态的情况下，对methodA()方法的调用-异常的捕获按父类声明的异常处理。

public class A {
    public void methodA() throws IOException {
    ……
} }
public class B1 extends A {
    public void methodA() throws FileNotFoundException {
    ……
} }
public class B2 extends A {
    public void methodA() throws Exception { //报错
    ……
} }

手动抛出异常

• Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出， 也可根据需要使用人工创建并抛出。
  • 首先要生成异常类对象， 然后通过throw语句实现抛出操作(提交给Java运行环境)。
    IOException e = new IOException();
throw e;
  • 可以抛出的异常必须是Throwable或其子类的实例。 下面的语句在编译时将会产生语法错误：
    throw new String("want to throw");

class Student{
	
	private int id;
	
	public void regist(int id) throws Exception {
		if(id > 0){
			this.id = id;
		}else{
			//手动抛出异常对象
//			throw new RuntimeException("您输入的数据非法！");
//			throw new Exception("您输入的数据非法！");
			throw new MyException("不能输入负数");

		}
		
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
	
	
}

throw 和 throws区别：

• throw 表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。
• throws 属于异常处理的一种方式，声明在方法的声明处。

用户自定义异常类

• 一般地，用户自定义异常类都是RuntimeException的子类。
• 自定义异常类通常需要编写几个重载的构造器。
• 自定义异常需要提供serialVersionUID
• 自定义的异常通过throw抛出。
• 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

用户自定义异常类MyException，用于描述数据取值范围错误信息。用户自己的异常类必须继承现有的异常类。

class MyException extends Exception {
    static final long serialVersionUID = 13465653435L;
    private int idnumber;
    public MyException(String message, int id) {
        super(message);
        this.idnumber = id;
    }
    public int getId() {
    	return idnumber;
    }
}

///############
public class MyExpTest {
    public void regist(int num) throws MyException {
        if (num < 0)
        	throw new MyException("人数为负值，不合理", 3);
        else
        	System.out.println("登记人数" + num);
        }
    public void manager() {
        try {
        	regist(100);
        } catch (MyException e) {
        	System.out.print("登记失败，出错种类" + e.getId());
        }
        System.out.print("本次登记操作结束");
    }
    public static void main(String args[]) {
        MyExpTest t = new MyExpTest();
        t.manager();
    }
}

//判断程序的输出结果
public class ReturnExceptionDemo {
    static void methodA() {
        try {
        	System.out.println("进入方法A");
        	throw new RuntimeException("制造异常");
        }finally {
       	 	System.out.println("用A方法的finally");
        }
    }
    static void methodB() {
        try {
            System.out.println("进入方法B");
            return;
        } finally {
            System.out.println("调用B方法的finally");
        }
    }
    public static void main(String[] args) {
        try {
        	methodA();
        } catch (Exception e) {
        	System.out.println(e.getMessage());
        }
        	methodB();
    }
}

/** 运行结果：
进入方法A
用A方法的finally
制造异常
进入方法B
调用B方法的finally*/

    

总结

• try-catch-finally:真正的将异常给处理掉了。

• throws的方式只是将异常抛给了方法的调用者。并没真正将异常处理掉。

体会开发中应该如何选择两种处理方式？

• 如果父类中被重写的方法没throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中异常，必须使用try-catch-finally方式处理。
• 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

补充：
方法重写的规则之一：子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

参考：

Java中类名与文件名的关系

尚硅谷_Java零基础教程-java入门必备-适合初学者的全套完整版教程(宋红康主讲)