面向对象

1工具类中使用静态

//静态方法
printArray(arr);
//非静态方法
ArrayDemo add = new Array Demo();
ad.printArray(arr);
测试类的作用：创建其他类的对象，调用其他类的功能
而我们现在的操作跟数组相关，所以，你应该把这些操作定义到数组操作中
定义一个数组的操作类

如果不想被访问数组
那么就在测试类中加入
private 类名；改为私有，数组中就不能创建对象，就不能访问

2工具类的完善

1为遍历数组
2为数组的最大值获取

// An highlighted block
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;
//获取最值
int max = ArrayTool.getMax(arr);
System.out.println("max:"+max);


指定元素在数组中第一次出现的索引
public static int getIndex(int[] arr,int value){
	int index = -1;
	for(int x=0; x<arr.length;x++){
		index = x;
		break;
}
}
	return index;
//获取数组某个数的索引值
int index = ArrayTool.getIndex(arr,55);
System.out.println("index:"+index);

说明书的制作过程

如何制造一个说明书：
A:写一个工具类
B:对这个类加入文档注释
怎么加/**
*/
加什么：
@author:作者
@version 版本
@param参数
@return返回值

C:用工具解析文档注释
javadoc工具
D:格式
	javadoc -d  目录 -author -version ArrayTool.java
	目录：就可以写一个文件夹的路径

制作帮助文档出错：
找不到可以文档化的公共或者受保护的类：告诉我们类的权限不够；

@author:作者
@version 版本
@param参数
@return返回值

如何使用JDK提供的帮助文档

1.打开帮助文档
2.点击显示，找到索引，看到输入框
3.知道你要找什么，以Scanner举例
4.在输入框中输入Scanner，然后回车
5.看包
java.lang包下的类不需要导入，其他全部需要导入
要导入：
提供的java.***.***(举例：java.util.Scanner)
6.再简单的看看类的解释和说明，别忘了看看该类的版本
7.看类的结构：
成员变量 字段摘要
构造方法 构造方法摘要
成员方法 方法摘要
8.学习构造方法
A:有构造方法 就创建对象
B:没有构造方法 成员可能都是静态的
9.看成员方法
A:左边
是否静态；如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收
B:右边
看方法名：方法名称不要写错
参数列表：人家要什么，你就给什么；人家要几个，你就给几个

通过JDK的帮助文档学习math类的随机数功能

/*
math:类包含用于执行基本数学运算的方法
由于math类在java.lang包下，所以不需要导包。
特点：
没有构造方法：因为它的成员全部是静态的，所以利用方法调用（double d = Math.random（））
掌握一个方法:
获取随机数
public static double random();返回带正号
*/

// An highlighted block
class MathDemo{
	public static void main(String[] args){
	//获取随机数
	double d = Math.random();
	System.out.println(d);
	//需求：我要获取一个1-100之间的随机数，
	int number  = (int)(Math.random()*100)+1;
	System.out.println(number);
}
}

代码块的概述和分类

代码块
在java中，使用{}括起来的代码都被称为代码块，根据其位置和声明的不同，
可以分为局部代码块，构造代码块，静态代码块，同步代码块。
局部代码块
在方法中出现，限定变量声明周期，及早释放，提高内存利用率
构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，
并且在构造方法前执行
作用：可以把多个构造方法的共同代码放到一起，对对象进行初始化
静态代码块在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰，用于给类进行初始化，在加载的时候就执行
并且只一次
作用：一般是对类进行初始化

面试题？
静态代码块，构造代码块，构造方法的执行顺序
静态代码块–构造代码块==构造方法
静态代码块：只执行一次
构造代码块：每次调用构造方法都执行

代码块看程序写结果

// An highlighted block
/*
写程序的执行结果
*/
class Student{

	//第二个执行（只执行一次）
	static{
	System.out.println("我是静态代码块")；
}
	//第三个执行（重复两次）
	{
	System.out.println("我是构造代码块")；
}
	public Studnet(){
	System.out.println("我是构造方法")；
}
}
class Student{

	//第一个执行
	static{
	System.out.println("我是静态代码块")；
}
	public static void main(String[] args){
		System.out.println("我是main方法")；
		Student s1 = new Student();
		Student s2 = new Student();
}
}

继承的引入和概述

继承概述:
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类
无需再定义这些属性和行为，只要继承那个类即可

通过extends关键字可以实现类与类的继承
	class子类名extends父类名{}

单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

格式：
class Person{
String name;
int age;

public person(){}
public void eat(){
Syste,.out.println("吃饭");

}
}

继承的好处

继承概述：把多个类中相同的内容给提取出来定义到一个类中
如何实现继承呢？
java提供了关键字：extends
格式：
class 子类名 extends 父类名{}
好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类产生关系，是多态的前提

继承的弊端

类与类产生了关系，其实也是继承的一个弊端；
类的耦合性增强了。
开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

java中类的继承特点

java中继承的特点
A:JAVA只支持单继承，不支持多继承、
有些语言是支持多继承，格式：extends 类1，类2；
B:JAVA支持多层继承（继承体系）

继承的注意事项和什么时候使用继承

java中继承的注意事项
子类只能继承父类所有非私有的成员（成员方法和成员变量）
其实这也体现了继承的另一个弊端：打破了封装性
子类不能继承父类的构造方法，但是可以通过super关键字访问父类构造方法。
不要为了部分功能而去继承
我们到底子什么时候使用继承呢？
继承中类之间体现的是：“is a”的关系（子类是父类的一种）
采用假设法：
如果有两个类A,B.只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承

继承中成员变量的关系

类的组成:
成员变量：
构造方法：
成员方法：
而现在我们又讲解了继承，所有，我们就应该来考虑一下，类的组成部分的各自关系
继承中成员变量的关系：
A:子类中的成员变量和父类中的成员变量名称不一样，这个很容易输出
B：子类的成员变量和父类中的成员变量名称意义，怎么办？
在子类方法中访问一个变量的查找顺序：
a:在子类方法的局部范围找，有就使用
b:在子类的成员范围找，有就使用
c:在父类的成员范围找，有就使用
d:如果还没有就报错（总结就近原则，离输出的方法越近就先调用）

// An highlighted block
class Father{
	public int num = 10;
}
class Son extends Father{
	public int num2 = 20;
	public int num = 30;
	public void show(){
		int num = 40;
	//打印结果为40，20
	System.out.println(num);
	System.out.println(num2);
}
}
class Extends{
	public static void main(String[] args){
	//创建对象
	Son s = new Son();
	s.show();
}
}

this和super的区别和应用

问题：
我不仅要输出局部范围的num，还要输出本类成员范围的num，怎么办?
(this.num)
我还想要输出父类成员范围的num。怎么办？
(super.num)

super的用法和this很像
this代表本类对应的引用
super代表父类内存空间的表示（可以理解为父类引用）
用法（this和super均可如下使用）
访问成员变量（this.成员变量）调用本类的成员变量
（super.成员变量） 调用父类的成员变量
访问构造方法（子父类的构造方法问题） this(…) super(…)
访问成员方法（子父类的成员方法问题） this成员方法（） super成员方法()

// An highlighted block
class Father{
	public int num = 10;
}
class Son extends Father{
	public int num = 20;
	public void show(){
	int num = 30;
	System.out.println(num);
	System.out.println(this.num);
	System.out.println(super.num);
}
}
class Exdents{
	public static void main(String[] args){
	//创建对象
	Son s = new Son();
	s.show();
} 
}

继承中构造方法的关系

继承中所有的构造方法默认都会访问父类中空参数的构造方法
为什么？
因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前
一定要先完成数据的初始化。
每一个构造方法的第一条语句默认都是super()

// An highlighted block
class Father{
	public Father(){
	System.out.println("Father的无参构造方法")
}
}
class Son extends Father{
	public Son(){
	System.out.println("Son的无参构造方法")
}
}
class Extends{
	public static void main(String[] args){
	//创建对象
	Son s = new Son();
}
}


class Father{
	public Father(){
	System.out.println("Father的无参构造方法")
}
	public Father(String name){
	System.out.println("Father的带参构造方法")//（不会访问父类的带参）
}
class Son extends Father{
	//super();
	public Son(){
	System.out.println("Son的无参构造方法")
}
	//super();
	public Son(String name){
	System.out.println("Son的带参构造方法")
}
class Extends{
	public static void main(String[] args){
	//创建对象
	Son s = new Son();
	System.out.println("---------------------");
}
}
	/*运行结果;Father的无参构造方法
	              Son的无参构造方法
	              Father的无参构造方法
	              Son的带参构造方法
	              */

继承中构造方法的注意事项

/*
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢？如何解决？
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化
注意事项：
this(…)或者super(…)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一位
*/

// An highlighted block
class Father{
	//带参不执行
	public Father(){
		System.out.println("Father的无参构造方法")；
}
	public Father(String namer){
		System.out.println("Father的带参构造方法")；
}
}
class Son extends Father{
	public Son(){
	System.out.println("Son的无参构造方法")；
	}
	public Son(String name){
	System.out.println("Son的带参构造方法")；
	}
}
class Extends{
	public static void main(String[] args){
		Son s = new Son();
}
}
	打印结果：Father的无参构造方法
		Son的无参构造方法
		Father的无参构造方法
		Son的带参构造方法




class Father{
	//带参不执行

/*
	public Father(){
		System.out.println("Father的无参构造方法")；
}
*/

	public Father(String namer){
		System.out.println("Father的带参构造方法")；
}
}
class Son extends Father{
	public Son(){
	super("随便给");
	System.out.println("Son的无参构造方法")；
	}
	public Son(String name){
	//super("随便给");
	this();//调用本类的无参构造，先走Son();就会经过super("");
	System.out.println("Son的带参构造方法")；
	}
}
class Extends{
	public static void main(String[] args){
		Son s = new Son();
}
}
	/*打印结果：Father的带参构造方法
		Son的无参构造方法
		Father的带参构造方法
		Son的带参构造方法*/

继承中的问题

A:成员变量 就近原则
B:this和super的问题
this访问本类的成员
super访问父类的成员
C:子类构造方法执行前默认先执行父类的无参构造方法
D:一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化

A：一个类的静态代码块，构造代码块，构造方法的执行流程
静态代码块>构造代码块>构造方法
B:静态的内容是随着类的加载而加载的
静态代码块的内容会优先执行
C：子类初始化之前会进行父类的初始化

子父类的初始化（分层初始化）
先进行父类初始化，然后进行子类初始化
问题：
虽然子类中构造方法默认有一个super（）
初始化的时候，不是按照那个顺序进行的。
而是按照分层初始化进行的

它仅仅表示要先初始化父类输出，在初始化子类数据

s.show()
s.method()
子类有就用子类，没有用父类，如果父类也没有就报错

// An highlighted block
class Fu{
	static{
	System.out.println("静态代码块Fu");
}
{
	System.out.println("构造代码块Fu");
}
	public Fu{
	System.out.println("构造方法Fu");
	}

}
class Zi extends Fu{
	static{
	System.out.println("静态代码块Zi");
}
{
	System.out.println("构造代码块Zi");
}
	public Zi{
	System.out.println("构造方法Zi");
	}
}
class Extends{
	public static void main(String[] args){
		Zi z = new Zi();
}
}

	/*结果：静态代码块Fu
	          静态代码块Zi
	          构造代码块Fu
	          构造方法Fu
	          构造代码块Zi
	          构造方法Zi
	          */

方法重写的应用

方法重写概述
子类中出现了和方法一模一样的方法声明，也被称为方法覆盖，方法复写
使用特点：
如果方法名不同，有就调用对应的方法
如果方法名相同，最终使用的是子类自己的
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的
方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

方法重写:子类中出现了和父类中方法声明一模一样的方法
方法重载：本类中出现的方法名一样，参数列表不同。与返回值无关

/*
方法重写：

通过研究，我发明了一个新手机 ，这个手机的作用时在打电话完了之后，可以听天气预报
按照我们的基本设计，我们把代码写出来
但是呢？我们又发现新手机应该时手机，所以它应该继承自手机
其实这个时候的设计，并不是最好的
因为手机打电话功能，时手机本身就具备的功能
所以，我的心手机时不用再提供这个功能
但是，这个时候，打电话功能就没有了
最终还是加这个功能，由于它继承了手机类，所以，我们直接使用父类的
那么，如何使用父类的功能呢，通过super关键字调用

// An highlighted block
 */

 class Phone{
	 public void call(String name) {
		 System.out.println("给"+name+"打电话");
	 }
 }
//用新手机继承手机
class NewPhone extends Phone{
	public void call(String name) {
		//如果子类没有那么直接引用父类
		//System.out.println("给"+name+"打电话");
		//利用super关键字引用
		super.call(name);
		System.out.println("听天气预报");
	}
}
public class Extends {

	public static void main(String[] args) {
		//创建对象
		NewPhone n = new NewPhone();
		n.call("小三");
	}

}

方法重写的注意事项

继承中成员方法的关系
方法重写的注意事项
父类中私有方法不能被重写
（因为父类私有方法子类根本无法继承）

	子类重写父类方法时，访问权限不能更低
	（子类访问权限不能低于父类，最少也是大于等于，最好等于）
	父类静态方法，子类也必须通过静态方法进行重写。

总结：子类重写父类方法的时候，最后声明一模一样

总结

1.如何制作帮助文档
（1）写一个类
（2）加入文档注释
（3）通过javadoc工具生成即可
javadoc - d 目录 -author-version ArrayTool.java
2.通过JDK提供的API学习了math类
（1）API（Application Programming Interface）
应用程序 编程 接口（俗称：帮助文档）
（2)Math类
A:是针对数学进行操作的类
B:没有构造方法，因为他的成员都是静态
C:产生随机数
public static double random():[0.0,1.0]
D:如何产生一个1-100之间的随机数
int number = (int)(Math.random()*100)+1;
E：猜数字小游戏
3.代码块
（1）用{}括起来的代码。
（2）分类：
A:局部代码块
用于限定变量的生命周期，及早释放，提高内存利用率
B:构造代码块
把多个构造方法中相同的代码可以放到这里，每个构造方法首先执行构造代码块
C:静态代码块
对类的数据进行初始化，仅仅只执行一次
（3）静态代码块，构造代码块，构造方法的顺序问题？
静态代码块>构造代码块>构造方法
4.继承
（1）把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
这多个类就具备了这些内容。这个关系叫继承
（2）java中如何表示继承呢？格式是什么呢？
A:用关键字extends表示
B:格式：
class 子类名 extends 父类名{}
（3）继承的好处：
A:提高了代码的复用性
B:提高代码的维护性
C:让类与类产生了一个关系，是多态的前提
（4）继承的弊端
A:让类的耦合性增强。这样某个类的改变，就会英雄其他和该类相关的类。
原则：低耦合，高内聚
耦合：类与类的关系
内聚：自己完成某件事情的能力
B:打破了封装性
（5）JAVA中继承的特点
A:java中类只支持单继承
B:Java中可以多层（重）继承（继承体系）
（6）继承的注意事项：
A:子类不能继承父类的私有成员
B:子类不能继承父类的构造方法，但是可以通过super去访问
C:不要为了部分功能而去继承
（7）什么时候才能继承呢？
A:继承体现的是:is a的关系
B:采用假设法
（8）Java继承中的成员关系
A:成员变量
a:子类的成员变量名称和父类中的成员变量名称不一样，这个简单，各自调各自的
b:子类的成员变量名称和父类中的成员变量名称一样，
子类的方法访问变量的查找顺序：
在子类方法的局部范围找，有就使用（就是子类方法{}中的部分）
在子类的成员范围找，有就使用（在子类中的所有部分就是在它class中找）
在父类的成员范围找，有就使用（在父类的class{}下找）
找不到就报错
B:构造方法
a:子类的构造方法默认会去访问父类的无参构造方法
是为了子类访问父类数据的初始化
b:父类如果没有无参构造方法，怎么办？
子类通过super去明确调用带参构造
子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
让父类提供无参构造
C:成员方法
a:子类的成员方法和父类的成员方法名称不一样，这个简单
b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问
在子类中找对应的方法，有就使用
在子类中找对应的方法，有就使用
没有就报错
（9）this 和super的区别和各自的作用？
this是针对本类的调用，super是针对父类的调用
this.变量名 super.变量名
this（…） super(…)
this.成员方法(),super.成员方法()

编者的话：终于写到面向对象了，感觉写的时候总是太慢了，特别费时间唉