黑马程序员——java基础--面向对象基础

class  TestTool
{
public static void main(String[] args)
{
int[] arr = {1,5,7,8,6,2,3};
ArrayTool.printArr(arr);       //直接类名调用
}
}

7. 帮助文档的制作

/*
每个用用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用
*/
public class  ArrayTool
{
/**
构造函数私有化
*/
private ArrayTool(){}
//获取最大值功能
/**
获取一个整形数组中的最大值
@param arr 接受一个int型的数组
@return 会返回该数组中的最大值
*/
public static int getMax(int[] arr)
{
int max = arr[0];
for(int x=1;x<arr.length;x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}
/**
获取一个整形数组中的最小值
@param arr 接受一个int型的数组
@return 会返回该数组中的最小值
*/
//获取最小值功能
public static int getMin(int[] arr)
{
int min = arr[0];
for(int x=1;x<arr.length;x++)
{
if(arr[x]<min)
min = arr[x];
}
return min;
}
/**
对int数组进行选择排序
@param arr 接受一个int型的数组
*/
//选择排序
public static void selectSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[y]<arr[x])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
/**
对int数组进行冒泡排序
@param arr 接受一个int型的数组
*/
//冒泡排序
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length ;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )
{
if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
/**
对int数组的元素进行位置置换
@param arr 接受一个int型的数组
@param a 要置换的位置
@param b 要置换的位置
*/
//位置置换
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
对int数组进行打印
@param arr 接受一个int型的数组
*/
//打印数组
public static void printArr(int[] arr)
{
System.out.print("[");
for (int x=0;x<arr.length ;x++ )
{
if (x!=arr.length)
{
System.out.print(arr[x]+",");
}
else
System.out.print(arr[x]);
}
System.out.print("]");

}
}

8. 对象初始化与调用成员的过程

9. 单例设计模式

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

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

//懒汉式，类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象
//也称为延迟加载形式。
class Single2

{
private static Single2 s = null;

private Single2(){}

public static Single2 getInstance()
{
if(s==null)
s = new Single2();
return s;
}
}

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;
}
}
class  SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();

Single s2 = Single.getInstance();

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

Test t1 = Test.getInstance();

Test t2 = Test.getInstance();

t1.setNum(10);

t2.setNum(20);

System.out.println(t1.getNum());

System.out.println(t2.getNum());
}
}

10. 继承

class Demo
{
void show1(){}
}

class DemoA extends Demo
{
void show1(){}
void show2(){}
}
class DemoB extends Demo
{
void show1(){}
void show3(){}
}

class Person
{
String name;
int age;
}
class Student extends Person//Student继承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();
Worker w = new Worker();
w.work();
}
}

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

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

11. 抽象类

/*
雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。
分析：
在这个问题领域中，先找出涉及的对象。
通过名词提炼法。
程序员：
属性：姓名，工号，薪水、
行为：工作。
经理：
属性：姓名，工号，薪水，奖金。
行为：工作。

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

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

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

*/

//描述雇员。

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

12. 接口

/*
abstract class AbsDemo
{
abstract void show1();
abstract void show2();
}

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是 接口 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();
}
//类与类之间是继承关系，类与接口直接是实现关系。
/*
接口不可以实例化。

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

*/

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

public void show2()
{

}
}
/*
在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(){}

}
/*
一个类在继承另一个类的同时，还可以实现多个接口。
*/
class Q
{
public void method()
{}
}

abstract class Test2 extends Q implements A,Z
{

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

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

13. 多态

/*
基础班学生
学习，睡觉
高级班学生
学习，睡觉
可以将这两类事物进行抽取
*/

abstract class Student
{
public abstract void study();
public viud sleep()
{
System.out.println("躺着睡");
}
}
class BaseStudent extends Student
{
public void study()
{
System.out.println("base study");
}
public void sleep()
{
System.out.println("坐着睡");
}
}
class AdvStudent extends Student
{
public void study()
{
System.out.println("adv study");
}
}

class DoStudent
{
public void doSome(Student s)
{
s.study();
s.sleep();
}
}
class  Demo
{
public static void main(String[] args)
{
DoStudent ds = new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
/*

BaseStudent bs = new BaseStudent();
bs.study();
bs.sleep();
AdvStudent as = new AdvStudent();
as.study();
as.sleep();
*/
}
}

/*
需求：获取一段程序运行的时间
原理：获取程序开始和结束的时间并相减就可以
*/
abstract class GetTime
{
public final void getTime()//用final修饰防止被复写
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println("毫秒："+(end-start));
}
public abstract void runcode();//因为不明确方法主体所以使用抽象方法
}

class  Test extends GetTime
{
public void runcode()
{
for(int x=0;x<1000;x++)
{
System.out.println(x);
}
}
}

/*
需求：
电脑运行实例，
电脑运行基于主板
*/

class MainBoard
{
public void run()
{
System.out.println("mainboard run");
}
public void useNetCard(NetCard c)
{
c.open();
c.close();
}
}
class NetCard
{
public void open()
{
System.out.println("netcard open");
}
public void close()
{
System.out.println("netcard close");
}
}
class  Computer
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
mb.useNetCard();
}
}

interface PCI
{
public void open();
public void close();
}
class MainBoard
{
public void run()
{
System.out.println("mainboard run");
}
public void usePCI(PCI p)
{
if(p!=null)
{
p.open();
p.close();
}
}
}
class NetCard implements PCI
{
public void open()
{
System.out.println("netcard open");
}
public void close()
{
System.out.println("netcard close");
}
}
class  Demo2
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
}
}

14. 内部类

/*
内部类
*/

class  Outer
{
int x=3;
class Inner
{
void function()
{
System.out.println("Inner:"+x);
}
}
void method()
{
Inner in = new Inner();
in.function();
}

}
class Main
{
public static void main(String[] args)
{
Outer out = new Outer();
//内部类访问
Outer.Inner in = new Outer().new Inner();
out.method();
}
}

15. 异常