黑马程序员——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