(壹)、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]);
        
    }
}
View Code

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);
    }

}
      View Code
  • 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();
    }
}
      View Code

       

  • 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);
    }
}
      View Code
    • 静态什么时候用？

      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!");
    }
}
      View Code
    • 静态代码块。

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

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

      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");
    }
}
      View Code
  • 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;
    }

}
    View Code

     

二、继承

  • 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();
    }
}
      View Code

    • 当本类的成员和局部变量同名用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();
    }
}
      View Code
    • 成员函数。

      当子父类中出现成员函数一模一样的情况，会运行子类的函数。
      这种现象，称为覆盖操作。这时函数在子父类中的特性。

    • 函数两个特性：

      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();
    }
}
      View Code
    • 子父类中的构造函数的特点。

      在子类构造对象时，发现，访问子类构造函数时，父类也运行了。
      为什么呢？
      原因是：在子类的构造函数中第一行有一个默认的隐式语句。 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;
    }
    */
}
      View Code
  • 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();
    }
}
      View Code 
  • 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!");
    }
}
      View Code
  • 7.抽象类

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

    • 特点：

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

    • 1，抽象类中有构造函数吗？

      　　有，用于给子类对象进行初始化。

    • 2，抽象类可以不定义抽象方法吗？

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

    • abstract class Demo
    {
        void show1()
        {}
        

        void show2()
        {}
    }
      View Code
    • 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!");
    }
}
      View Code
    • /*
雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。



分析：
在这个问题领域中，先找出涉及的对象。
通过名词提炼法。
程序员：
    属性：姓名，工号，薪水、
    行为：工作。
经理：
    属性：姓名，工号，薪水，奖金。
    行为：工作。


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

但是程序员和经理却具有共性内容。
可以进行抽取。因为他们都是公司的雇员 

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

//描述雇员。

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);
    }

}
      View Code
  • 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();
}
      View Code

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

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

      class DemoImpl implements /*实现*/Demo
{
    public void show1()
    {}

    public void show2()
    {
    
    }
}
      View Code

    • 在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(){}
    
}
      View Code

       

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

      class Q
{
    public void method()
    {}
}

abstract class Test2 extends Q implements A,Z
{

}
      View Code

       

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

      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);
    }
}
      View Code

       

    • 抽象类和接口的异同点：

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

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

      //犬按功能分：有导盲犬，搜爆犬。


abstract class 犬
{
    abstract void 吼叫();
}

//abstract class 导盲
interface 导盲
{
    abstract void 导盲();
}


class 导盲犬 extends 犬 implements 导盲
{
    public void 吼叫()
    {
    }
    public void 导盲(){}
}



//在不同的问题领域中，有不同的分析方式。
/*
学员：
    学习。
    抽烟学员




烟民。*/
      View Code　　

三、多态

  • 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)
    {    
        
    }
    */    
}
      View Code 
      /*
毕老师和毕姥爷的故事。
*/

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.看电影();




    }
}
      View Code　
  • 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);
    }
}
      View Code　
  • 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();
        
    }
}
      View Code
  • 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();
    }
}
      View Code

       

    • 内部类可以存放在局部位置上。
      内部类在局部位置上只能访问局部中被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();
      View Code

       

      　　
  • 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();
    }
}
      View Code 
      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();
    }
}
      View Code 
      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();
    }
}
      View Code
      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();
        

    }
}
      View Code

       

  • 6.异常
  • 7.throwable中的方法
  • 8.异常处理
  • 9.自定义异常
  • 10.异常细节
  • 11.包
  • 12.包之间的访问
  • 13.四种权限
  • 14.import
  • 15.jar
  • 16.jar包的操作
posted @ 2013-08-13 20:00  为了这有限的生命  阅读(653)  评论(0)  编辑  收藏  举报