黑马程序员---java基础之day8-9

------- android培训、java培训、期待与您交流！ ----------

第八天：

对象数组工具的建立：

       class ArrayToolDemo

{

       /*

       保证程序的独立运行。

       */

       public static voidmain(String[] args)

       {

              int[] arr ={4,8,2,9,72,6};

 

//            ArrayTooltool = new ArrayTool();

//            intmax= ArrayT8ool.getMax(arr);

//            System.out.println("max="+max);

              int index =ArrayTool.getIndex(arr,8);

              System.out.println("index="+index);

       }

}

//文档注释：javadoc

       /**

建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等。

@author 张三

@version V1.0

*/

 

public class  ArrayTool

{

       private ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象

                                          //可以将构造函数私有化。

 

       /**

       获取整型数组的最大值。

       @paramarr 接收一个元素为int类型的数组。

       @return该数组的最大的元素值

       */

       public static intgetMax(int[] arr)

       {

              int maxIndex = 0;

              for(int x=1;x<arr.length; x++)

              {

                     if(arr[x]>arr[maxIndex])

                                   maxIndex= x;//

              }

 

              return arr[maxIndex];

       }

       /**

       对数组进行选择排序。

       @paramarr 接收一个元素为int类型的数组。

      

       */

       public static voidselectSort(int[] arr)

       {

              for(int x=0;x<arr.length-1; x++)

              {

                     for(inty=x+1; y<arr.length; y++)

                     {

                            if(arr[x]>arr[y])

                                   swap(arr,x,y);

                     }

              }

       }

 

       /*

       用于给数组进行元素的位置置换。

       @paramarr 接收一个元素为int类型的数组。

       @parama

       @paramb

      

       */

       private static voidswap(int[] arr,int a,int b)

       {

              int temp =arr[a];

              arr[a] = arr[b];

              arr[b] = temp;

       }

      

       /**

       获取指定的元素在指定数组中的索引.

       @paramarr 接收一个元素为int类型的数组。

       @paramkey 要找的元素。

       @return返回该元素第一次出现的位置，如果不存在返回-1.

       */

       public static intgetIndex(int[] arr,int key)

       {

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

              {

                     if(arr[x]==key)

                            returnx;

              }

              return -1;

       }

 

       /**

       将int数组转换成字符串。格式是：[e1,e2,...]

       @paramarr 接收一个元素为int类型的数组。

       @return返回该数组的字符串表现形式。

       */

       public static StringarrayToString(int[] arr)

       {

              String str ="[";

 

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

              {

                     if(x!=arr.length-1)

                            str= str + arr[x]+", ";

                     else

                            str= str + arr[x]+"]";

              }

              return str;

       }

}

 

面向对象的设计模式（一种思想）：

       /*

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

 

1,单例设计模式。

       解决的问题：就是可以保证一个类在内存中的对象唯一性。

 

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

 

如何保证对象唯一性呢？

1，不允许其他程序用new创建该类对象。

2，在该类创建一个本类实例。

3，对外提供一个方法让其他程序可以获取该对象。

 

步骤：

1，私有化该类构造函数。

2，通过new在本类中创建一个本类对象。

3，定义一个公有的方法，将创建的对象返回。

 

 

 

*/

 

//饿汉式

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

{

       private static Single s= new Single();

 

       private Single(){}

 

       public static SinglegetInstance()

       {

              return s;

       }

}

 

 

//懒汉式(存在安全隐患，多线程操作时，不能保证对象的唯一性。单线程使用效率高)

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

                     //延迟加载形式。

{

       private static Single2 s= null;

 

       private Single2(){}

 

       public static Single2getInstance()

       {

              if(s==null)

                     s = newSingle2();

              return s;

       }

}

 

 

class  SingleDemo

{

       public static voidmain(String[] args)

       {

              Single s1 =Single.getInstance();

              Single s2 =Single.getInstance();

 

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

             

//            Singless = Single.s;

 

//            Testt1 = new Test();

//            Testt2 = 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 TestgetInstance()

       {

              return t;

       }

       public void setNum(intnum)

       {

              this.num = num;

       }

       public int getNum()

       {

              return num;

       }

 

}

 

 

继承：

 

/*

继承的好处：

       1，提高了代码的复用性。

       2，让类与类之间产生了关系，给第三个特征多态提供了前提.

 

 

 

java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。

 

单继承：一个子类只能有一个直接父类。

 

多继承：一个子类可以有多个直接父类(java中不允许,进行改良)

              不直接支持，因为多个父类中有相同成员，会产生调用不确定性。

              在java中是通过"多实现"的方式来体现。

 

 

java支持多层(多重)继承。

 

C继承B，B继承A。

就会出现继承体系。

 

当要使用一个继承体系时，

1，查看该体系中的顶层类，了解该体系的基本功能。

2，创建体系中的最子类对象，完成功能的使用。

 

class Demo

{

       voidshow1(){}

}

 

 

class DemoA extends Demo

{

//     void show1(){}

       voidshow2(){}

}

class DemoB extends Demo

{

//     void show1(){}

       voidshow3(){}

}

 

什么时候定义继承呢？

 

当类与类之间存在着所属关系的时候，就定义继承。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

{

       Stringname;

       intage;

}

 

 

 

class Student extends/*继承*/Person

{

//     String name;

//     int age;

       voidstudy()

       {

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

       }

}

 

 

class Worker extends Person

{

//     String name;

//     int age;

       voidwork()

       {

              System.out.println("workerwork");

       }

}

 

 

class ExtendsDemo

{

       publicstatic void main(String[] args)

       {

              Students = new Student();

              s.name="zhangsan";

              s.age= 22;

              s.study();

       }

}

 

/*

在子父类中，成员的特点体现。

1，成员变量。

2，成员函数。

3，构造函数。

 

 

 

*/

 

//1，成员变量。

 

/*

当本类的成员和局部变量同名用this区分。

当子父类中的成员变量同名用super区分父类。

 

this和super的用法很相似。

 

this:代表一个本类对象的引用。

super：代表一个父类空间。子类能访问父类是因为持有指向父类的super引用

 

 

 

*/

class Fu

{

       privateint num = 4;

 

       publicint getNum()

       {

              returnnum;

       }

}

 

 

class Zi extends Fu

{

       privateint num = 5;//变量不存在覆盖一说

 

 

       voidshow()

       {

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

       }

}

 

 

class ExtendsDemo2

{

       publicstatic void main(String[] args)

       {

              Ziz = new Zi();

              z.show();

       }

}

 

 

 

 

//成员函数。

/*

当子父类中出现成员函数一模一样的情况，会运行子类的函数。

这种现象，称为覆盖操作。这时函数在子父类中的特性。

函数两个特性：

       1，重载。同一个类中。overload

       2，覆盖。子类中。覆盖也称为重写，覆写。override

      

覆盖注意事项：

1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。

2，静态只能覆盖静态，或被静态覆盖。

 

 

 

 

 

 

*/

class Fu

{

       publicstatic  void show()

       {

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

       }

}

 

class Zi extends Fu

{

       publicstatic void show()

       {

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

       }

}

 

class ExtendsDemo3

{

       publicstatic void main(String[] args)

       {

//            Zi z = new Zi();

//            z.show();

              NewPhonep = new NewPhone();

              p.show();

              p.call();

       }

}

 

/*

什么时候使用覆盖操作?

 

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

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

 

*/

class honeP

{

       voidcall()

       {}

       voidshow()

       {           

              System.out.println("number");

       }

}

 

class NewPhone extends Phone

{

       voidshow()

       {

              System.out.println("name");

              System.out.println("pic");

              super.show();

       }

}

 

 

 

第九天：

 

继承-子父类中的构造函数-子类的实例化过程

       /*

子父类中的构造函数的特点。

 

在子类构造对象时，发现，访问子类构造函数时，父类也运行了。

为什么呢？

原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();

 

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

      

                    

为什么子类实例化的时候要访问父类中的构造函数呢？

那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，

要先看父类是如何对自己的内容进行初始化的。

 

所以子类在构造对象时，必须访问父类中的构造函数。

为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。

 

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用

父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，

那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。

但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

 

 

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

 

 

 

 

 

*/

 

class Fu

{

       intnum ;

       Fu()

       {

              num=10;

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

       }

       Fu(intx)

       {

              System.out.println("Bfu run..."+x);

       }

}

class Zi extends Fu

{

       intnum;

       Zi()

       {

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

             

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

       }

       Zi(intx)

       {

              this();

              //super();

//            super(x);  //没有指定参数时，则super()。指定后不执行super()

              System.out.println("Dzi run "+x);

       }

}

 

class ExtendsDemo4

{

       publicstatic void main(String[] args)

       {

              newZi(6);

       }

}

class Demo//extends Object

{

       /*

      

       Demo()

       {

              super();

              return;

       }

       */

}

 

 

 

 

 

classFu

{

       Fu()

       {

              super();

              show();

              return;

       }

 

       voidshow()

       {

              System.out.println("fushow");

       }

}

class Zi extends Fu

{

       intnum = 8;

       Zi()

       {

              super();

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

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

 

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

              return;

       }

       voidshow()

       {

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

       }

}

class ExtendsDemo5

{

       publicstatic void main(String[] args)

       {

              Ziz = new Zi();

              z.show();

       }

}

 

/*

一个对象实例化过程：

Person p = newPerson();

1，JVM会读取指定的路径下的Person.class文件，并加载进内存，

       并会先加载Person的父类(如果有直接的父类的情况下).

2，在堆内存中的开辟空间，分配地址。

3，并在对象空间中，对对象中的属性进行默认初始化。

4，调用对应的构造函数进行初始化。

5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。

6，父类初始化完毕后，在对子类的属性进行显示初始化。

7，在进行子类构造函数的特定初始化。

8，初始化完毕后，将地址值赋值给引用变量.

*/

 

 

Final关键字：

Final可以修饰类，方法，变量

Final修饰的类不可以被继承。

Final修饰的方法不可以被覆盖

Final修饰的变量是一个常量。只能被赋值一次。

内部类只能访问被final修饰的局部变量

 

//继承弊端：打破了封装性。

/*

final关键字：

1，final是一个修饰符，可以修饰类，方法，变量。

2，final修饰的类不可以被继承。

3，final修饰的方法不可以被覆盖。

4，final修饰的变量是一个常量，只能赋值一次。

       为什么要用final修饰变量。其实在程序如果一个数据是固定的，

       那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。

       而且这个变量名称的值不能变化，所以加上final固定。

 

       写法规范：常量所有字母都大写，多个单词，中间用_连接。

 

 

 

*/

class Fu

{

       voidmethod()

       {

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

       }

}

class Zi extends Fu

{

       publicstatic final double MY_PI = 3.14;

       staticfinal int x = 7;

 

       voidmethod()

       {

//            final int x = 9;

//            x = 9;

              finalint NUMBER = 9;

             

              System.out.println(MY_PI);

       }

}

 

class FinalDemo

{

       publicstatic void main(String[] args)

       {

              System.out.println("HelloWorld!");

       }

}

 

抽象类：

 

/*

抽象类：

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

 

比如：狼和狗有共性的内容，吼叫，一旦有共性内容就可以向上抽取。但具体吼叫方式不同

这就要在定义共性内容的类中把吼叫定义成抽象方法，狼和狗类继承该类后，就可以覆盖该抽象方法，定义成自己的吼叫方式

 

特点：

1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。

       抽象方法必须定义在抽象类中。该类必须也被abstract修饰。

2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。

3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。

       否则，这个子类还是抽象类。

 

 

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

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

 

 

      

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

       可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。

       通常这个类中的方法有方法体，但是却没有内容。

 

       abstract class Demo

       {

              void show1()

              {}

             

 

              void show2()

              {}

       }

 

 

 

3，抽象关键字不可以和那些关键字共存?

       private 不行：象方法是要进行覆盖操作的，private修饰后把方法隐藏起来就不能进行覆盖操作

       static不行：静态方法可以被类名直接调用，调用没有意义。抽象类不能创建对象是因为调用方法没有意义

       final 不行：抽象方法是要进行覆盖操作的，而final修饰的方法是不能被覆盖的，水火不相容

 

 

 

4，抽象类和一般类的异同点。

       相同点：

              抽象类和一般类都是用来描述事物的，都在内部定了成员。

       不同：

              1，一般类有足够的信息描述事物。

                抽象类描述事物的信息有可能不足。

              2，一般类中不能定义抽象方法，只能定非抽象方法。

                抽象类中可定义抽象方法，同时也可以定义非抽象方法。

              3，一般类可以被实例化。

                抽象类不可以被实例化。

 

 

 

 

5，抽象类一定是个父类吗？

       是的。因为需要子类覆盖其方法后才可以对子类实例化。

 

 

 

 

*/

 

abstract class Demo

{

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

      

}

 

/*

 

class DemoA extendsDemo

{

       void show()

       {

              System.out.println("demoashow");

       }

}

class DemoB extendsDemo

{

       void show()

       {

              System.out.println("demobshow");

       }

}

*/

abstract class 犬科

{

       abstractvoid 吼叫();

}

 

class 狗 extends 犬科

{

      

       void吼叫()

       {

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

       }

}

class 狼 extends 犬科

{

       void吼叫()

       {

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

       }

}

 

 

 

class AbstractDemo

{

       publicstatic void main(String[] args)

       {

              System.out.println("HelloWorld!");

       }

}

 

/*

雇员示例：

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

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

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

 

 

 

分析：

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

通过名词提炼法。

程序员：

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

       行为：工作。

经理：

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

       行为：工作。

 

 

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

 

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

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

 

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

      

*/

 

//描述雇员。

 

abstract class Employee

{

       privateString name;

       privateString id;

       privatedouble pay;

       Employee(Stringname,String id,double pay)

       {

              this.name= name;

              this.id= id;

              this.pay= pay;

       }

 

       publicabstract void work();

      

}

 

 

//描述程序员。

class Programmer extends Employee

{

       Programmer(Stringname,String id,double pay)

       {

              super(name,id,pay);

       }

       publicvoid work()

       {

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

       }

}

 

//描述经理。

class Manager extends Employee

{

       privateint bonus;

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

       {

              super(name,id,pay);

              this.bonus= bonus;

       }

       publicvoid work()

       {

              System.out.println("manage");

       }

}

 

class AbstractTest

{

       publicstatic void main(String[] args)

       {

              System.out.println("HelloWorld!");

       }

}

 

 

class Person

{

       privateString name;

       privateint age;

 

       Person(Stringname,int age)

       {

              this.name= name;

              this.age= age;

       }

       publicString getName()

       {

              returnname;

       }

       publicvoid setName(String name)

       {

              this.name= name;

       }

}

class Student extends Person

{

       Student(Stringname,int age)

       {

              super(name,age);

       }

 

}

class Worker extends Person

{

       Worker(Stringname,int age)

       {

              super(name,age);

       }

 

}

 

接口：

/*

abstract classAbsDemo

{

       abstract void show1();

       abstract void show2();

}

 

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用

另一种形式定义和表示，就是接口 interface。

*/

 

//定义接口使用的关键字不是class，是interface.

/*

对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1，全局常量: public static final

 

2，抽象方法。public abstract

 

由此得出结论，接口中的成员都是公共的权限.

 

接口中可以省略固定修饰符，但阅读性差，接口中的方法是要进行覆盖的，必须拥有最高权限，因此写上阅读性强些

 

 

如果把全局常量的修饰符public static final去掉，会误以为是变量，阅读性极差。

*/

interface Demo

{

       publicstatic final int NUM = 4;

 

       publicabstract void show1();

       publicabstract void show2();

}

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

/*

接口不可以实例化。

 

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。

否则，这个子类就是一个抽象类。

 

*/

 

 

class DemoImpl implements /*实现*/Demo

{

       publicvoid show1()

       {}

 

       publicvoid show2()

       {

      

       }

}

 

 

/*

在java中不直接支持多继承，因为会出现调用的不确定性。

所以java将多继承机制进行改良，在java中变成了多实现。

 

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

 

*/

 

interface A

{

       publicvoid show();

}

 

interface Z

{

       publicint add(int a,int b);

}

 

 

 

 

class Test implements A,Z//多实现

{

      

       publicint add(int a,int b)

       {

              returna+b+3; 

       }

       /**/

       publicvoid show(){}

      

}

 

/*

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

 

 

 

*/

class Q

{

       publicvoid method()

       {}

}

 

abstract class Test2 extends Q implementsA,Z

{

 

}

/*

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

 

*/

 

 

interface CC

{

       voidshow();

}

interface MM

{

       voidmethod();

}

 

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

{

       voidfunction();

}

 

class WW implements QQ

{

//覆盖3个方法。

       publicvoid show(){}

       publicvoid method(){}

       publicvoid function(){}

}

 

 

class InterfaceDemo

{

       publicstatic void main(String[] args)

       {

 

              Testt = 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 犬

{

       abstractvoid 吼叫();

}

 

//abstract class 导盲

interface 导盲

{

       abstractvoid 导盲();

}

 

 

class 导盲犬 extends 犬 implements 导盲

{

       publicvoid 吼叫()

       {

       }

       publicvoid 导盲(){}

}

 

 

 

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

学员：

       学习。

       抽烟学员

 

 

 

 

烟民。

      

 

*/

 

class InterfaceDemo

{

       publicstatic void main(String[] args)

       {

              System.out.println("HelloWorld!");

       }

}