黑马程序员——Java基础——数组工具类、设计模式和继承(一)

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

数组工具类：

/**
 * 数组工具类和文档注释
 * @author maidou51
 * @version v1.0
 */
class ArrayTool {
	//该类中的方法都是静态的,所以该类时不需要创造对象的
	//未来保证不让他人创建对象,可以将构造函数私有化
	private ArrayTool(){}
	/**
	 * 获取整型数组的最大值
	 * @param arr 接收一个元素为int 类型的数组
	 * @return 该数组的最大的元素值
	 * */
	//获取整形数组的最大值
	public static int getMax(int[] arr){
		int maxIndex = 0;
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]>arr[maxIndex]){
				maxIndex = i;
			}
		}
		return arr[maxIndex];
	}
	/**
	 * 对数组进行选择排序
	 * @param arr接收一个元素为int的数组
	 * */
	//对数组进行选择排序
	public static void 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);
				}
			}
		}
	}
	//用于给数组进行元素的位置置换.
	private static void swap(int[] arr, int i ,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	/**
	 * 获取指定的元素在指定数组中的索引
	 * @param arr 接收一个元素为int 类型的素组
	 * @param key 要找的元素
	 * @return 返回该元素第一次出现的位置,如果不存在则返回-1
	 * */
	//获取指定的元素在指定数组中的索引
	public static int getIndex(int[] arr,int key){
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]==key){
				return i;
			}
		}
		return -1;
	}
	/**
	 * 将int素组转换陈字符串,格式是:[e1,e2...]
	 * @param arr 接收一个元素为int 类型的数组
	 * @return 返回该数组的字符串表现形式
	 * */
	//将int数组转换字符串,格式是:[e1,e2...]
	public static String arrayToString(int[] arr){
		String str = "[";
		for (int i = 0; i < arr.length; i++) {
			if(i !=arr.length-1){
				str = str + arr[i]+",";
			}else{
				str = str +arr[i]+"]";
			}
		}
		return str;
	}
}
public class ArrayToolDemo {
	//保证程序的独立运行
	public static void main(String[] args) {
		int[] arr = {1,2,5,8,6,3,34};
		int max = ArrayTool.getMax(arr);
		System.out.println("max="+max);
		int index = ArrayTool.getIndex(arr, 3);
		System.out.println("index="+index);
	}
}

运行结果：

max=34
index=5

单列设计模式

/**
 * 单例设计模式
 * 设计模式:对问题行之有效的解决方式,一种思想
 * 解决的问题:就是可以保证一个类在内存中的对象唯一性
 * 比如多个程序使用同一个配置信息对象时,就需要保证对象的唯一性.
 * 思路:
 * 1.不允许其他程序用new创建该类对象.
 * 2.在该类创建一个本类实例.
 * 3.提供一个方法让其他程序可以获取该对象.
 * 步骤:
 * 1.私有化构造函数.
 * 2.通过new在本类中创建一个静态并私有本类对象.
 * 3.定义一个公有的静态方法,将创建的对象返回.
 */
//饿汉式--直接用
class Single_Hungry{
	private Single_Hungry(){}
	static private Single_Hungry sh = new Single_Hungry();
	public static Single_Hungry getInstance(){
		return sh;
	}
}
//懒汉式--先null
class Single_Lazy{
	private Single_Lazy(){}
	private static  Single_Lazy sl = null;
	public static Single_Lazy getInstance(){
		if(sl==null){
			sl =new Single_Lazy();
		}
		return sl;
	}
}

public class SingleDemo {

	public static void main(String[] args) {
		Single_Hungry sh1 = Single_Hungry.getInstance();
		Single_Hungry sh2 = Single_Hungry.getInstance();
		System.out.println(sh1.equals(sh2));
		Single_Lazy sl1 = Single_Lazy.getInstance();
		Single_Lazy sl2 = Single_Lazy.getInstance();
		System.out.println(sl1.equals(sl2));
	}
}

输出结果：

true
true

继承：

/**
 * 继承:通过extends关键字让类与类之间产生继承关系.
 * 多个类中存在相同的属性和行为时,将这些内容抽取到单独一个类中,
 * 那么多个类无需再定义这些属性和行为,只需要继承那个类即可.
 * 1.子类可以直接访问父类中的非私有属性和行为.
 * 2.子类无法继承父类中私有的内容.
 * 3.父类怎么来的?共性不断向上抽取来的.
 */
class A{
	void show(){
		System.out.println("A");
	}
}
class B{
	void show(){
		System.out.println("B");
	}
}
/**
 * 注意:
 * 1.Java只支持单继承,不支持多继承
 * 2.一个类只能有一个父类,不可以有多个父类.
 * 原因:因为多继承容易出现问题.两个父类中有的方法,子类到底要执行哪一个是不确定的.
 */
//class C extends B,A{}

class Person{
	String name;
	int age;
}
class Student extends Person{
	void study(){
		System.out.println("学生好好学习,天天向上  "+age);
	}
}
class Worker extends Person{
	void work(){
		System.out.println("工人好好工作~赚money~  "+age);
	}
}

public class ExtendsDemo {

	public static void main(String[] args) {
		Student s = new Student();
		s.age = 20;
		s.name = "宝坛";
		s.study();
		Worker w = new Worker();
		w.name = "隔壁老五";
		w.age = 35;
		w.work();
	}
}
/*
 * 继承的好处:
 * 1.提高了代码的复用性
 * 2.让类与类产生了关系,提供了多台的前提.
 */
/**
 * java不支持多继承,但将这种机制换了另一个安全的方式来实现,也就是多实现(接口).
 * Java支持多层继承(继承体系):
 * C继承B,B继承A,就会出现继承体系.
 * 多层继承出现的继承体系中,通常看父类中的功能,
 * 了解该体系的基本功能,建立子类对象,即可使用该体系功能.
 * 定义继承需要注意:
 * 		不要仅为了获取其他类中的某个功能去继承,类与类之间要所有属("is a")关系.
 */

运行结果

学生好好学习,天天向上  20
工人好好工作~赚money~  35

继承的重写（覆盖）：

package cn.fuxi.zhabaotan3;
/**
 * 什么时候使用覆盖操作?
 * 当子类需要父类的功能,而功能主题子类有自己特有内容时,
 * 可以复写父类中的方法,这样,继沿袭了父类的功能,又定义了子类特有的内容
 * 
 * p.s.
 * 1.父类中的私有方法不可以被覆盖
 * 2.父类为static的方法无法覆盖
 * 3.覆盖时,子类方法的权限一定要大于父类方法权限
 */
class Phone{
	void call(){}
	void show(){
		System.out.println("number");
	}
}
class NewPhone extends Phone{
	public void show(){
		System.out.println("name");
		System.out.println("pic");
		super.show();
	}
}

public class ExtendsDemo2 {
	public static void main(String[] args) {
		NewPhone p = new NewPhone();
		p.show();
	}
}

运行结果：

name
pic
number

构造函数：

/**
 * 构造函数
 * 子父类构造函数的特点:
 * 在子类构造函数执行时,发现的父类构造函数也运行了.
 * 原因:在子类的构造函数中,第一行有一个默认的隐式语句:super();
 * 注意:
 * 		如果使用super(4);语句调用父类的其他构造函数,
 * 		那么默认的父类构造函数将不会再被调用.
 */
class Fu2{
	int num;
	Fu2(){
		num = 10;
		System.out.println("A fu run");
	}
	Fu2(int x){
		System.out.println("B fu run..."+x);
	}
}
class Zi2 extends Fu2{
	Zi2(){
		//隐藏语句:super();
		System.out.println("C zi run "+num);
	}
	Zi2(int x){
		super(4);
		System.out.println("D zi run "+ x);
	}
}

public class ExtendsDemo3 {
	public static void main(String[] args) {
		new Zi2();
		System.out.println("------------------------");
		new Zi2(6);
	}
}

运行结果:

A fu run
C zi run 10
------------------------
B fu run...4
D zi run 6