(壹)、java面向对象详解

面向对象的概述：

1.用java语言对现实生活中的事物进行描述。通过类的形式来体现的。

2.怎么描述呢？
　　对于事物描述通常只关注两方面。
　　一个是属性，一个是行为。

3.成员变量和局部变量的区别：

　　①成员变量定义在类中，整个类中都可以访问。局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

　　②成员变量存在于堆内存的对象中。局部变量存在于栈内存的方法中。

　　③成员变量随着对象的创建而存在，随着对象的消失而消失。局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

　　④成员变量都有默认初始化值。局部变量没有默认初始化值。

4.类的使用

　　①在计算机中创建一个car的实例。通过new关键字。

Car c = new Car();// c就是一个类类型的引用变量，指向了该类的对象。
　　　　　　　　　　　//匿名对象：只使用一次的对象
c.run();　　//要使用对象中的内容可以通过  对象.成员 的形式来完成调用。

/*匿名对象。没有名字的对象。
new Car();//匿名对象。其实就是定义对象的简写格式。*/

1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

new Car().num = 5;
new Car().color = "green";
new Car().run();

2，匿名对象可以作为实际参数进行传递。

// Car c1 = new Car();
// show(c1);
show(new Car());

public static void show(Car c)//类类型的变量一定指向对象。要不就是null。

    {

        c.num = 3;

        c.color = "black";

        System.out.println(c.num+"..."+c.color);

    }

5.主函数

/*

public static void main(String[] args) 

主函数特殊之处：

1，格式是固定的。

2，被jvm所识别和调用。

public:因为权限必须是最大的。

static:不需要对象的,直接用主函数所属类名调用即可。

void：主函数没有具体的返回值。

main:函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

*/

class MainDemo

{

    public static void main(String[] args) //new String[0]

    {

        /**/

//        System.out.println(args);//[Ljava.lang.String;@c17164

        System.out.println(args.length);

        for(int x=0; x<args.length; x++)

            System.out.println(args[x]);

    }

}

6.new关键字

一、面向对象

1.面向对象概念
2.类与对象的关系
3.封装
- 　类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
  //可以将构造函数私有化。　
4.构造函数
- 构造方法定义：构造方法是为类中的属性初始化的。
- 构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。
  创建对象都必须要通过构造函数初始化。
- 一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
  如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
- 一般函数和构造函数什么区别呢？
- 构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
  一般函数：对象创建后，需要函数功能时才调用。
  
  构造函数：对象创建时，会调用只调用一次。
  一般函数：对象创建后，可以被调用多次。
- 什么时候定义构造函数呢？
- 在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。
  构造函数可以有多个，用于对不同的对象进行针对性的初始化.
  多个构造函数在类中是以重载的形式来体现的。
- 细节：
- 1，构造函数如果完成了set功能。set方法是否需要。
  2，一般函数不能直接调用构造函数。
  3，构造函数如果前面加了void就变成了一般函数。
  4，构造函数中是有return语句的。
- ```
class Person

{

    private String name;

    private int age;

    //定义一个Person类的构造函数。

    Person()//构造函数，而且是空参数的。

    {

        name = "baby";

        age = 1;

        System.out.println("person run");

    }

    //如果有的孩子一出生就有名字。

    Person(String n)

    {

        name = n;

    }

    public void setName(String n)

    {

        name = n;

    }

    Person(String n,int a)

    {

        name = n;

        age = a;

    }

    public void speak()

    {

        System.out.println(name+":"+age);

    }

}
```

5.this关键字

当成员变量和局部变量重名，可以用关键字this来区分。

this : 代表对象。代表哪个对象呢？当前对象。
this就是所在函数所属对象的引用。
简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

this也可以用于在构造函数中调用其他构造函数。
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

class Person

{

    private String name;

    private int age;

    Person()

    {

        name = "baby";

        age = 1;

        System.out.println("person run");

    }

    Person(String name)

    {

        this();

        this.name = name;

    }

    Person(String name,int age)

    {

        this.name = name;

        this.age = age;

    }

    public void speak()

    {

        System.out.println(this.name+":"+this.age);

    }

    /*

    判断是否是同龄人。

    */

    public boolean compare(Person p)

    {

        /*

        if(this.age==p.age)

            return true;

        else

            return false;

        */

        return this.age==p.age;

    }

}

class ThisDemo

{

    public static void main(String[] args)

    {

        Person p1 = new Person("aa",30);//

        Person p2 = new Person("zz",12);

        p2.compare(p1);

//        new Person();

//        Person p = new Person("旺财",30);

//        p.speak();

//        Person p1 = new Person("小强");

//        p1.speak();

    }

}

6.static关键字

static的特点：
1，static是一个修饰符，用于修饰成员。
2，static修饰的成员被所有的对象所共享。
3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。
4，static修饰的成员多了一种调用方式，就可以直接被类名所调用。类名.静态成员。
5，static修饰的数据是共享数据，对象中的存储的是特有数据。
成员变量和静态变量的区别？
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。
3，主函数是静态的。

class Person

{

    String name;//成员变量，实例变量

    static String country = "CN";//静态变量。类变量

    public  void show()

    {

        System.out.println(Person.country+":"+this.name);

    }

}

静态什么时候用？
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的
没有访问特有数据的方法，该对象的创建是没有意义。

class Demo

{

    int age ;

    static int num = 9;

    Demo(int age)

    {

        this.age = age;

    }

    public static  void speak()

    {

        System.out.println(num);

    }

    public void show()

    {

        System.out.println(age);

    }

}

class  StaticDemo3

{

    public static void main(String[] args)

    {

//        Demo d = new Demo(30);

//        d.speak();

        Demo.speak();

//        System.out.println("Hello World!");

    }

}

静态代码块。

随着类的加载而执行。而且只执行一次。

作用：
用于给类进行初始化。

class StaticCode

{

    static int num ;

    static

    {

        num = 10;

//        num *=3;

        System.out.println("hahahah");

    }

    StaticCode(){}

    static void show()

    {

        System.out.println(num);

    }

}

class Person

{

    private String name;

    {//构造代码块。可以给所有对象进行初始化的。

        System.out.println("constructor code ");

//        cry();

    }

    static

    {

        System.out.println("static code");

    }

    Person()//是给对应的对象进行针对性的初始化。

    {

        name = "baby";

//        cry();

    }

    Person(String name)

    {

        this.name  = name;

//        cry();

    }

    public void cry()

    {

        System.out.println("哇哇");

    }

    public void speak()

    {

        System.out.println("name:"+name);

    }

    static void show()

    {

        System.out.println("show run");

    }

}

class StaticCodeDemo

{

    static

    {

//        System.out.println("a");

    }

    public static void main(String[] args)

    {

//        Person p = null;

//        p.speak();

//        Person.show();

//        Person p1 = new Person();

//        p1.speak();

//        Person p2 = new Person("旺财");

//        p2.speak();

//        new Person();

//        new StaticCode().show();

//        new StaticCode().show();

//        StaticCode.show();

//        System.out.println("b");

    }

}

7.单例设计模式
设计模式：对问题行之有效的解决方式。其实它是一种思想。

1,单例设计模式。
解决的问题：就是可以保证一个类在内存中的对象唯一性。

必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？
1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。

步骤：
1，私有化该类构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。

//饿汉式

class Single//类一加载，对象就已经存在了。

{

    private static Single s = new Single();

    private Single(){}

    public static Single getInstance()

    {

        return s;

    }

}

//懒汉式

class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。

            //延迟加载形式。

{

    private static Single2 s = null;

    private Single2(){}

    public static Single2 getInstance()

    {

        if(s==null)

            s = new Single2();

        return s;

    }

}

class  SingleDemo

{

    public static void main(String[] args)

    {

        Single s1 = Single.getInstance();

        Single s2 = Single.getInstance();

        System.out.println(s1==s2);

//        Single ss = Single.s;

//        Test t1 = new Test();

//        Test t2 = new Test();

        Test t1 = Test.getInstance();

        Test t2 = Test.getInstance();

        t1.setNum(10);

        t2.setNum(20);

        System.out.println(t1.getNum());

        System.out.println(t2.getNum());

    }

}

class Test

{

    private int num;

    private static Test t = new Test();

    private Test(){}

    public static Test getInstance()

    {

        return t;

    }

    public void setNum(int num)

    {

        this.num = num;

    }

    public int getNum()

    {

        return num;

    }

}

二、继承

1.继承的概述

继承的好处：

1，提高了代码的复用性。
2，让类与类之间产生了关系，给第三个特征多态提供了前提.
java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。
单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类(java中不允许,进行改良)
不直接支持，因为多个父类中有相同成员，会产生调用不确定性。
在java中是通过"多实现"的方式来体现。
java支持多层(多重)继承。

C继承B，B继承A。
就会出现继承体系。

当要使用一个继承体系时，
1，查看该体系中的顶层类，了解该体系的基本功能。
2，创建体系中的最子类对象，完成功能的使用。

class Demo

{

    void show1(){}

}

class DemoA extends Demo

{

//    void show1(){}

    void show2(){}

}

class DemoB extends Demo

{

//    void show1(){}

    void show3(){}

}

什么时候定义继承呢？

当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。 xxx extends yyy

所属关系： is a 关系。

*/

/*

class A

{

    void show()

    {

        System.out.println("a");

    }

}

class B

{

    void show()

    {

        System.out.println("b");

    }

}

class C extends A,B

{

}

new C().show();

*/

class Person

{

    String name;

    int age;

}

class Student extends/*继承*/ Person

{

//    String name;

//    int age;

    void study()

    {

        System.out.println(name+"...student study.."+age);

    }

}

class Worker extends Person

{

//    String name;

//    int age;

    void work()

    {

        System.out.println("worker work");

    }

}

class ExtendsDemo

{

    public static void main(String[] args)

    {

        Student s = new Student();

        s.name= "zhangsan";

        s.age = 22;

        s.study();

    }

}

当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
this和super的用法很相似。
this:代表一个本类对象的引用。
super：代表一个父类空间。

class Fu

{

    private int num = 4;

    public int getNum()

    {

        return num;

    }

}

class Zi extends Fu

{

    private int num = 5;

    void show()

    {

        System.out.println(this.num+"....."+super.getNum());

    }

}

class ExtendsDemo2

{

    public static void main(String[] args)

    {

        Zi z = new Zi();

        z.show();

    }

}

成员函数。
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作。这时函数在子父类中的特性。
函数两个特性：
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override
覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
2，静态只能覆盖静态，或被静态覆盖。

class Fu

{

    public static  void show()

    {

        System.out.println("fu show run");

    }

}

class  Zi extends Fu

{

    public static void show()

    {

        System.out.println("Zi show run");

    }

}

class ExtendsDemo3

{

    public static void main(String[] args)

    {

//        Zi z = new Zi();

//        z.show();

        NewPhone p = new NewPhone();

        p.show();

        p.call();

    }

}

/*

什么时候使用覆盖操作?

当对一个类进行子类的扩展时，子类需要保留父类的功能声明，

但是要定义子类中该功能的特有内容时，就使用覆盖操作完成.

*/

class honeP

{

    void call()

    {}

    void show()

    {

        System.out.println("number");

    }

}

class NewPhone extends Phone

{

    void show()

    {

        System.out.println("name");

        System.out.println("pic");

        super.show();

    }

}

子父类中的构造函数的特点。
在子类构造对象时，发现，访问子类构造函数时，父类也运行了。
为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，
要先看父类是如何对自己的内容进行初始化的。

所以子类在构造对象时，必须访问父类中的构造函数。
为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用
父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，
那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。
但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。

class Fu

{

    int num ;

    Fu()

    {

        num =10;

        System.out.println("A fu run");

    }

    Fu(int x)

    {

        System.out.println("B fu run..."+x);

    }

}

class Zi extends Fu

{

    int num;

    Zi()

    {

        //super();//调用的就是父类中的空参数的构造函数。

        System.out.println("C zi run"+num);

    }

    Zi(int x)

    {

        this();

        //super();

//        super(x);

        System.out.println("D zi run "+x);

    }

}

class  ExtendsDemo4

{

    public static void main(String[] args)

    {

        new Zi(6);

    }

}

class Demo//extends Object

{

    /*

    Demo()

    {

        super();

        return;

    }

    */

}

2.继承的特点
3.super关键字
4.函数覆盖

5.子类的实例化过程

一个对象实例化过程：

Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.

class Fu

{

    Fu()

    {

        super();

        show();

        return;

    }

    void show()

    {

        System.out.println("fu show");

    }

}

class Zi extends Fu

{

    int num = 8;

    Zi()

    {

        super();

        //-->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，

        //才进行子类的成员变量显示初始化。

        System.out.println("zi cons run...."+num);

        return;

    }

    void show()

    {

        System.out.println("zi show..."+num);

    }

}

class ExtendsDemo5

{

    public static void main(String[] args)

    {

        Zi z = new Zi();

        z.show();

    }

}

6.final关键字
- 继承弊端：打破了封装性。
- final关键字：
  1，final是一个修饰符，可以修饰类，方法，变量。
  2，final修饰的类不可以被继承。
  3，final修饰的方法不可以被覆盖。
  4，final修饰的变量是一个常量，只能赋值一次。
  为什么要用final修饰变量。其实在程序如果一个数据是固定的，
  那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。
  而且这个变量名称的值不能变化，所以加上final固定。
  
  写法规范：常量所有字母都大写，多个单词，中间用_连接。
```
class Fu

{

    void method()

    {

        //调用了底层系统的资源。

    }

}

class Zi extends Fu

{

    public static final double MY_PI = 3.14;

    static final int x = 7;

    void method()

    {

//        final int x = 9;

//        x = 9;

        final int NUMBER = 9;

        System.out.println(MY_PI);

    }

}

class FinalDemo

{

    public static void main(String[] args)

    {

        System.out.println("Hello World!");

    }

}
```

7.抽象类

抽象类：
抽象：笼统，模糊，看不懂！不具体。
特点：

1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
否则，这个子类还是抽象类。
1，抽象类中有构造函数吗？

　　有，用于给子类对象进行初始化。
2，抽象类可以不定义抽象方法吗？

可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo

    {

        void show1()

        {}

        void show2()

        {}

    }

3，抽象关键字不可以和那些关键字共存?
private 不行
static 不行
final 不行
4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
抽象类不可以被实例化。
5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。

abstract class Demo

{

    abstract /*抽象*/ void show();

}

/*

class DemoA extends Demo

{

    void show()

    {

        System.out.println("demoa show");

    }

}

class DemoB extends Demo

{

    void show()

    {

        System.out.println("demob show");

    }

}

*/

abstract class 犬科

{

    abstract void 吼叫();

}

class 狗 extends 犬科

{

    void 吼叫()

    {

        System.out.println("汪汪");

    }

}

class 狼 extends 犬科

{

    void 吼叫()

    {

        System.out.println("嗷嗷");

    }

}

class AbstractDemo

{

    public static void main(String[] args)

    {

        System.out.println("Hello World!");

    }

}

/*

雇员示例：

需求：公司中程序员有姓名，工号，薪水，工作内容。

项目经理除了有姓名，工号，薪水，还有奖金，工作内容。

对给出需求进行数据建模。

分析：

在这个问题领域中，先找出涉及的对象。

通过名词提炼法。

程序员：

    属性：姓名，工号，薪水、

    行为：工作。

经理：

    属性：姓名，工号，薪水，奖金。

    行为：工作。

程序员和经理不存在着直接继承关系，

但是程序员和经理却具有共性内容。

可以进行抽取。因为他们都是公司的雇员 

可以将程序员和经理进行抽取.建立体系.

*/

//描述雇员。

abstract class Employee

{

    private String name;

    private String id;

    private double pay;

    Employee(String name,String id,double pay)

    {

        this.name = name;

        this.id = id;

        this.pay = pay;

    }

    public abstract void work();

}

//描述程序员。

class Programmer extends Employee

{

    Programmer(String name,String id,double pay)

    {

        super(name,id,pay);

    }

    public void work()

    {

        System.out.println("code...");

    }

}

//描述经理。

class Manager extends Employee

{

    private int bonus;

    Manager(String name,String id,double pay,int bonus)

    {

        super(name,id,pay);

        this.bonus = bonus;

    }

    public void work()

    {

        System.out.println("manage");

    }

}

class  AbstractTest

{

    public static void main(String[] args)

    {

        System.out.println("Hello World!");

    }

}

class Person

{

    private String name;

    private int age;

    Person(String name,int age)

    {

        this.name = name;

        this.age = age;

    }

    public String getName()

    {

        return name;

    }

    public void setName(String name)

    {

        this.name = name;

    }

}

class Student extends Person

{

    Student(String name,int age)

    {

        super(name,age);

    }

}

class Worker extends Person

{

    Worker(String name,int age)

    {

        super(name,age);

    }

}

8.接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是接口 interface。
定义接口使用的关键字不是class，是interface.
对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1，全局常量: public static final
2，抽象方法。public abstract
由此得出结论，接口中的成员都是公共的权限.
```
interface Demo

{

    public static final int NUM = 4;

    public abstract void show1();

    public abstract void show2();

}
```
类与类之间是继承关系，类与接口直接是实现关系。

接口不可以实例化。
只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。
```
class DemoImpl implements /*实现*/Demo

{

    public void show1()

    {}

    public void show2()

    {

    }

}
```

在java中不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行改良，在java中变成了多实现。

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

interface A

{

    public void show();

}

interface Z

{

    public int add(int a,int b);

}

class Test implements A,Z//多实现

{

    public int add(int a,int b)

    {

        return a+b+3;

    }

    /**/

    public void show(){}

}

一个类在继承另一个类的同时，还可以实现多个接口。

class Q

{

    public void method()

    {}

}

abstract class Test2 extends Q implements A,Z

{

}

接口的出现避免了单继承的局限性。

interface CC

{

    void show();

}

interface MM

{

    void method();

}

interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。

{

    void function();

}

class WW implements QQ

{

//覆盖3个方法。

    public void show(){}

    public void method(){}

    public void function(){}

}

class InterfaceDemo

{

    public static void main(String[] args)

    {

        Test t = new Test();

        t.show();

//        DemoImpl d = new DemoImpl();

//        System.out.println(d.NUM);

//        System.out.println(DemoImpl.NUM);

//        System.out.println(Demo.NUM);

    }

}

抽象类和接口的异同点：

相同点：
都是不断向上抽取而来的。

不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
接口的实现是 like a 关系，在定义体系额外功能。
```
//犬按功能分：有导盲犬，搜爆犬。

abstract class 犬

{

    abstract void 吼叫();

}

//abstract class 导盲

interface 导盲

{

    abstract void 导盲();

}

class 导盲犬 extends 犬 implements 导盲

{

    public void 吼叫()

    {

    }

    public void 导盲(){}

}

//在不同的问题领域中，有不同的分析方式。

/*

学员：

    学习。

    抽烟学员

烟民。*/
```

三、多态

1.定义

　

对象的多态性。

class 动物
{}

class 猫 extends 动物
{}

class 狗 extends 动物
{}

猫 x = new 猫();
动物 x = new 猫();//一个对象，两种形态。

猫这类事物即具备者猫的形态，又具备着动物的形态。
这就是对象的多态性。

简单说：就是一个对象对应着不同类型.

多态在代码中的体现：
父类或者接口的引用指向其子类的对象。

多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：
前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：
1，必须有关系，继承，实现。
2，要有覆盖。

abstract class Animal

{

    abstract void eat();

}

class Dog extends Animal

{

    void eat()

    {

        System.out.println("啃骨头");

    }

    void lookHome()

    {

        System.out.println("看家");

    }

}

class Cat extends Animal

{

    void eat()

    {

        System.out.println("吃鱼");

    }

    void catchMouse()

    {

        System.out.println("抓老鼠");

    }

}

class Pig extends Animal

{

    void eat()

    {

        System.out.println("饲料");

    }

    void gongDi()

    {

        System.out.println("拱地");

    }

}

class DuoTaiDemo

{

    public static void main(String[] args)

    {

//        Cat c = new Cat();

//        c.eat();

//        c.catchMouse();

        Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。

                            //作用就是限制对特有功能的访问。

                            //专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。

//        a.eat();

        //如果还想用具体动物猫的特有功能。

        //你可以将该对象进行向下转型。

//        Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。

//        c.eat();

//        c.catchMouse();

//        注意：对于转型，自始自终都是子类对象在做着类型的变化。

//        Animal a1 = new Dog();

//        Cat c1 = (Cat)a1;//ClassCastException

        /*

        Cat c = new Cat();

//        Dog d = new Dog();

//        c.eat();

        method(c);

//        method(d);

//        method(new Pig());

        */

        method(new  Dog());

    }

    public static void method(Animal a)//Animal a = new Dog();

    {

        a.eat();

        if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断

//                        //通常在向下转型前用于健壮性的判断。

        {

            Cat c = (Cat)a;

            c.catchMouse();

        }

        else if(a instanceof Dog)

        {

            Dog d = (Dog)a;

            d.lookHome();

        }

        else

        {

        }

    }

    /*

    public static void method(Cat c)

    {

        c.eat();

    }

    public static void method(Dog d)

    {    

    }

    */

}

/*

毕老师和毕姥爷的故事。

*/

class 毕姥爷

{

    void 讲课()

    {

        System.out.println("管理");

    }

    void 钓鱼()

    {

        System.out.println("钓鱼");

    }

}

class 毕老师 extends 毕姥爷

{

    void 讲课()

    {

        System.out.println("Java");

    }

    void 看电影()

    {

        System.out.println("看电影");

    }

}

class  DuoTaiDemo2

{

    public static void main(String[] args)

    {

//        毕老师 x = new 毕老师();

//        x.讲课();

//        x.看电影();

        毕姥爷 x = new 毕老师();

        x.讲课();

        x.钓鱼();

        毕老师 y = (毕老师)x;//ClassCastException

        y.看电影();

    }

}

2.特点
- 多态时，
  成员的特点：
  1，成员变量。
  编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
  运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
  简单说：编译和运行都参考等号的左边。哦了。
  作为了解。
  
  2，成员函数(非静态)。
  编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
  运行时：参考的是对象所属的类中是否有调用的函数。
  简单说：编译看左边，运行看右边。
  
  因为成员函数存在覆盖特性。
  
  3，静态函数。
  编译时：参考引用型变量所属的类中的是否有调用的静态方法。
  运行时：参考引用型变量所属的类中的是否有调用的静态方法。
  简单说，编译和运行都看左边。
  
  其实对于静态方法，是不需要对象的。直接用类名调用即可。
```
class Fu

{

//    int num = 3;

    void show()

    {

        System.out.println("fu show");

    }

    static void method()

    {

        System.out.println("fu static method");

    }

}

class Zi extends Fu

{

//    int num = 4;

    void show()

    {

        System.out.println("zi show");

    }

    static void method()

    {

        System.out.println("zi static method");

    }

}

class  DuoTaiDemo3

{

    public static void main(String[] args)

    {

        Fu.method();

        Zi.method();

        Fu f = new Zi();//

//        f.method();

//        f.show();

//        System.out.println(f.num);

//        Zi z = new Zi();

//        System.out.println(z.num);

    }

}
```

3.内部类

内部类访问特点：

1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。

一把用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述

class Outer

{

    private static int num = 31;

    class Inner// 内部类。

    {

        void show()

        {

            System.out.println("show run..."+num);

        }

        /*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。

        {

            System.out.println("function run ...."+num);

        }

        */

    }

    public void method()

    {

        Inner in = new Inner();

        in.show();

    }

}

class InnerClassDemo

{

    public static void main(String[] args)

    {

//        Outer out = new Outer();

//        out.method();

        //直接访问外部类中的内部类中的成员。

//        Outer.Inner in = new Outer().new Inner();

//        in.show();

        //如果内部类是静态的。 相当于一个外部类

//        Outer.Inner in = new Outer.Inner();

//        in.show();

        //如果内部类是静态的，成员是静态的。

//        Outer.Inner.function();

    }

}

4.内部类的位置

为什么内部类能直接访问外部类中成员呢？
那是因为内部类持有了外部类的引用。外部类名.this

class Outer

{

    int num = 3;

    class Inner

    {

        int num = 4;

        void show()

        {

            int num = 5;

            System.out.println(Outer.this.num);

        }

    }

    void method()

    {

        new Inner().show();

    }

}

class InnerClassDemo2

{

    public static void main(String[] args)

    {

        new Outer().method();

    }

}

内部类可以存放在局部位置上。
内部类在局部位置上只能访问局部中被final修饰的局部变量。

class Outer

{

    int num = 3;

    Object method()

    {

        final int x = 9;

        class Inner

        {

            public String toString()

            {

                return "show ..."+x;

            }

        }

        Object in = new Inner();

        return in;//0x0045

//        in.show();

    }

}

class InnerClassDemo3

{

    public static void main(String[] args)

    {

        Outer out = new Outer();

        Object obj = out.method();

        System.out.println(obj);

    }

}

/*

class Fu extends Object

{

}

class zi extends Fu

{

}

Fu f = new zi();

Object o = new Fu();

5.匿名内部类

　　

匿名内部类。就是内部类的简写格式。

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

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

abstract class Demo

{

    abstract void show();

}

class Outer

{

    int num = 4;

    /*

    class Inner extends Demo

    {

        void show()

        {

            System.out.println("show ..."+num);

        }

    }

    */

    public void method()

    {

        //new Inner().show();

        new Demo()//匿名内部类。

        {

            void show()

            {

                System.out.println("show ........"+num);

            }

        }.show();

    }

}

class InnerClassDemo4

{

    public static void main(String[] args)

    {

        new Outer().method();

    }

}

interface Inter

{

    void show1();

    void show2();

}

class Outer

{

    /*

    class Inner implements Inter

    {

        public void show1()

        {

        }

        public void show2()

        {

        }

    }

    */

    public void method()

    {

//        Inner in = new Inner();

//        in.show1();

//        in.show2();

        Inter in = new Inter()

        {

            public void show1()

            {

            }

            public void show2()

            {

            }

        };

        in.show1();

        in.show2();

    }

}

/*

通常的使用场景之一：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递

*/

class InnerClassDemo5

{

    class Inner

    {

    }

    public static void main(String[] args)

    {

        System.out.println("Hello World!");

        /*

        show(new Inter()

        {

            public void show1(){}

            public void show2(){}

        });

        */

//        new Inner();

    }

    public void method()

    {

        new Inner();

    }

    public static void show(Inter in)

    {

        in.show1();

        in.show2();

    }

}

class Outer

{

    void method()

    {

        Object obj = new Object()

        {

            public void show()

            {

                System.out.println("show run");

            }

        };

        obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型。

                    //这样就不能在使用子类特有的方法了。

    }

}

class InnerClassDemo6

{

    public static void main(String[] args)

    {

        new Outer().method();

    }

}

interface Inter

{

    void show();

}

class Outer

{

    //补足代码 (建议用匿名内部类)

    static Inter method()

    {

        return new Inter()

        {

            public void show(){}

        };

    }

}

/*

class haha implements Inter

{

    public void show(){}

}

*/

class  InnerClassTest

{

    public static void main(String[] args)

    {

        Outer.method().show();

    }

}

6.异常
7.throwable中的方法
8.异常处理
9.自定义异常
10.异常细节
11.包
12.包之间的访问
13.四种权限
14.import
15.jar
16.jar包的操作