day08_java面向对象(数组的工具类+单例设计模式+继承)

01-面向对象(数组工具对象建立)

ArrayTool.java里面的练习:

下面是一些数组工具的练习

练习的有:

l  获取整型数组的最大值。

//  获取整型数组的最大值。

    public
int getMax_1(int[] arr)

    {

        int max = arr[0];//初始化数组中的任何一个数

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

            if (max<arr[i])

            {

                max = arr[i];

            }

        }

       

        return max;

    }

    // 获取整型数组的最大值。

    public
int getMax_2(int[] arr)

    {

        int max = 0;
// 初始化数组中的任何一个角标

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

            if (arr[max]<arr[i])

            {

                max = i;

            }

        }

        return arr[max];

    }

l  对数组进行选择排序。

// 选择排序

    public
int[] selectSort(int[] arr)

    {

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

            for (int j = i+1; j < arr.length; j++) {

                if (arr[i]>arr[j])

                {

                    swap(arr,i,j);

                }

            }

        }

        return arr;

    }

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

public
int arrIndex(int[] arr,int key)

    {

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

            if (arr[i]==key)

            {

                return i;

            }

        }

        return -1;

    }

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

public String conString(int[] arr)

    {

        String str = "[";

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

            if (i != arr.length-1)

            {

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

            }else

            {

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

            }

        }

        return str;

    }

在这个工具类里面的设计原理也只要这个方法没有访问到这个对象里面的特有数据就应该静态化

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

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

 

数组工具类-文档注释

Java中提供了一个工具来提取java文档中的注释，但前提是你在java文件是写了文档的注释才会被提取，这个工具就是javadoc

Javadoc的使用

 

单例设计模式-概述&体现

有了方法才可控

 

/*

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

 

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 TestgetInstance()

    {

        return
t;

    }

    public
void setNum(int num)

    {

        this.num = num;

    }

    public
int getNum()

    {

        return
num;

    }

 

}

 

单例设计模式-内存图解



真真在面试的时候懒汉式一般问的比较多，然而也在真真的开发中饿汉式用的比较多为什么也不用懒汉式，因为在后面的多线程的时候会有问题，这里面只作一个了解





注意：子类不可以具备父类中私有的内容。

父类怎么来的？共性不断向上抽取而来的。





08-面向对象(继承-Java中的单继承和多重继承)

现在解释为什么java不直接支持多继承，事例:

class A

{

       voidshow()

       {

              System.out.println("a");

       }

}

class B

{

       voidshow()

       {

              System.out.println("b");

       }

}

class C extends A,B

{

}

newC().show();，当执行这条语句的时候也，C这个对象不知道调用哪一个，会产生不确定性，这就是为什么java不直接支持多继承的原因



因为多继承容易出现问题。

两个父类中有相同的方法。子类到底要执行哪一个是不确定的。

所以java不支持多继承，但将这种机制换了另一个种安全的方式来体现，多实现。

多次继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。

 

/*

继承的好处：

    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 关系。

 

*/

 

 

面向对象(继承-子父类中成员变量的特点)

 

/*

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

1，成员变量。

2，成员函数。

3，构造函数。

*/

 

//1，成员变量。

 

/*

当本类的成员和局部变量同名用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 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();

    }

}