day8 java基础（继承）

----------------------------------------知识点1--------------------------------------------------
/*
制作帮助文档

在同一个文件夹下，类定义在两个文件中和定义在同一个文件中是一样的

*/
class ArrayDemo{
public static void main(String [] args){
//int [] arr = new int []{1,2,3};
int [] arr = {1,2,3};
//arr[0]=1;
//arr[1]=2;
//arr[2]=3;

//遍历数组
/*for (int x = 0;x<arr.length;x++){
	System.out.println(arr[x]);
}
*/
// 如果有多个数组需要进行遍历
// 采用方法
//printArray(arr);
// 定义一个数组类
//ArrayDemo a = new ArrayDemo();
//a.printArray(arr);
ArrayTool a = new ArrayTool();
a.printArray(arr);
// 要是把方法改成静态方法就可以直接用类名调用
ArrayTool.printArray(arr);
}
/*public void printArray(int [] arr){
	for (int x = 0;x<arr.length;x++){
		if(x==arr.length-1){
			System.out.println(arr[x]);
		}else{
			System.out.print(arr[x]+",");
		}
	}
}*/

}
class ArrayTool{
// 把构造方法私有，外界就不能再创建对象了
private ArrayTool(){}

public static void printArray(int [] arr){
	for (int x = 0;x<arr.length;x++){
		if(x==arr.length-1){
			System.out.println(arr[x]);
		}else{
			System.out.print(arr[x]+",");
		}
	}
}

}
----------------------------------------知识点2--------------------------------------------------
/*
如何制作一个说明书
1.写一个工具类
2.对这个类加入文档注释
怎么加?
加些什么东西？
3.用工具解析文档注释
javadoc工具
4.格式
javadoc -d 目录 -author -version ArrayTool.java
目录：就可以写一个文件夹的路径

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

*/
class ArrayDemo{
public static void main(String [] args){
//int [] arr = new int []{1,2,3};
int [] arr = {1,2,3};

//遍历数组
ArrayTool.printArray(arr);

// 寻找最大值
int result = ArrayTool.getMax(arr);
System.out.println(result);

// 寻找固定值的索引
int index = ArrayTool.getIndex(arr,44);
System.out.println(index);
}

}
----------------------------------------知识点3--------------------------------------------------
/**

• 这是针对数组进行操作的工具类
• @author 陈小康
• @version v1.0
  */

public class ArrayTool{
// 把构造方法私有，外界就不能再创建对象了
/**
* 这个是私有构造
*/
private ArrayTool(){}

//遍历
/**
* 这个是遍历数组的方法，遍历后的格式是：[元素1，元素2，元素3，...]
*@param arr 这是要遍历的数组
*
*/
public static void printArray(int [] arr){
	System.out.println("[");
	for (int x = 0;x<arr.length;x++){
		if(x==arr.length-1){
			System.out.println(arr[x]+"]");
		}else{
			System.out.print(arr[x]+",");
		}
	}
}
/**
* 这个是获取数组中最大值的方法
*@param  arr 这是要获取最大值的数组
*@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;
}
/**
* 获取指定元素在数组中第一次出现的索引，如果元素不存在，返回-1
*@param arr 被查找的数组
*@param  value 要查找的元素
*@return  返回元素在数组中的索引
*/
// 查找索引
public static int getIndex(int [] arr,int value){
	int index = -1;
	for(int x = 0;x<arr.length;x++){
		if(arr[x]==value){
			index = x;
			break;
		}
	}
	return index;
}

}
----------------------------------------知识点4--------------------------------------------------
/*
猜数字小游戏（数据在1-100之间）
*/
import java.util.Scanner;
class GuessNumber{
public static void main(String [] args){
// 产生一个1-100数字
int number = (int)(Math.random()*99+1);
System.out.println(“游戏开始！”);
while(true){
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你猜的数字：”);
int number2 = sc.nextInt();

	if (number2>number){
		System.out.println("你输入的"+number2+"大了");
	}
	if (number2<number){
		System.out.println("你输入的"+number2+"小了");
	}
	if (number2==number){
		System.out.println("恭喜你！你输入的"+number2+"猜对了");
		break;
	}
}

}

}
----------------------------------------知识点5--------------------------------------------------
/*
获取一个随机数

Math.random()方法
	public static double random()返回带正号的 double 值，
			该值大于等于 0.0 且小于 1.0

*/

class MathDemo{
public static void main(String [] args){
// 获取一个随机数
double x = Math.random();
System.out.println(x);

// 需求：我要一个1-100之间的随机数
for(int m =1;m<101;m++){
	int y = (int) (100*Math.random()+1);
	System.out.print(y+"\t");
	if(m%10==0){
			System.out.println();
	}
}
}

}
----------------------------------------知识点6--------------------------------------------------
1:打开帮助文档
2：电机显示，找到索引，看到输入框
3: 知道要找谁，以Scanner为例
4：在输入框中输入Scanner，然后回车
5：看包
java.lang包下的类不需要导入，其他的全部都要导入

要导入：
 java.util.Scanner;

6: 简单看一下类的说明和注释，别忘了看版本
7：看类的结构
成员变量 字段摘要
构造方法 构造方法摘要
成员方法 方法摘要
8：学习构造方法
1.有构造方法就创建对象
2.没有构造方法 成员可能是静态的
9：看成员方法
1.左边
是否静态，如果静态，可以通过类名调用
返回值值类型：返回什么就用什么接收
2.右边
看方法名：方法名称不要写错
参数列表：人家要什么就给什么

----------------------------------------知识点7--------------------------------------------------
/*
代码块：在java中，使用{}括起来的代码成为代码块。
根据其位置和声明的不同，可以分为
局部代码块 ：局部位置,用于限定变量的周期。提高内存的使用效率。
构造代码块: 在类中成员的位置,用大括号{}括起来的代码，在每次调用构造函数前都会执行一次
静态代码块：在类中的成员位置，只不过用sataic修饰
作用：一般是对类进行初始化

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

*/
class Code{
static {
int y =10000;
System.out.println(y);
}

// 构造代码块
{
	int x = 10;
	System.out.println(x);
}

public Code(){}

{
	int y =100;
	System.out.println(y);
}

}

class CodeDemo{
public static void main (String [] args){
// 局部代码块
{
int x = 10;
System.out.println(x);

	}
	//System.out.println(x);//: 错误: 找不到符号 System.out.println(x);
	
	Code c = new Code();
	System.out.println("--------------");
	Code c2 = new Code();
}

}
----------------------------------------知识点8--------------------------------------------------
/*
写程序的执行结果
结果为：StudentDemo static
这个是main方法
Student static
Student 构造方法代码块
Student 构造方法
----------
Student 构造方法代码块
Student 构造方法

	注意:在StudentDemo类中才能运行Student,所以先加载StudetnDemo类
		且static修饰的代码块，只运行一次

*/

class Student{
static {
System.out.println("Student static ");
}
// 构造代码块
{
System.out.println(“Student 构造方法代码块”);
}
// 构造方法
public Student(){
System.out.println(“Student 构造方法”);
}
}

class StudentDemo{
static {
System.out.println(“StudentDemo static”);
}

public StudentDemo(){
		System.out.println("StudentDemo 构造方法");
	}
	
	{
		System.out.println("StudentDemo 构造方法代码块");
	}
	
public static void main(String [] args){
	System.out.println("这个是main方法");
	Student s = new Student();
	System.out.println("----------");
	Student s1 = new Student();
	
}

}
----------------------------------------知识点9--------------------------------------------------
/*
继承概述：
把多个类中相同的内容提取出来定义到一个类中

如何实现继承呢
		java提供了关键字：extends

格式：
	class 子类名 extends 父类名{}

好处：
	1.提高了代码的复用性
	2.提高了代码的维护性
	3.让类与类之间产生了关系，是多态的前提

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

*/
/*class Student{
public void eat(){
System.out.println(“吃饭”);
}

public void sleep(){
	System.out.println("睡觉");
}

}

class Teacher{
public void eat(){
System.out.println(“吃饭”);
}

public void sleep(){
	System.out.println("睡觉");
}

}
*/

class Person{
public void eat(){
System.out.println(“吃饭”);
}

public void sleep(){
	System.out.println("睡觉");
}

}

class Student extends Person{}

class Teacher extends Person{}

class ExtendsDemo{
public static void main(String [] args){
Student s = new Student();
s.eat();
s.sleep();
System.out.println("-------------");
Teacher t = new Teacher();
t.eat();
t.sleep();
}

}
----------------------------------------知识点10--------------------------------------------------
/*
JAVA 中继承的特点：
1.java只支持单继承，不支持多继承
有些语言支持多继承，格式 extend 类1，类2，…
2.java 支持多层继承（继承体系）
/
/
class Father{}
class Monther{}
class Son extends Father,Monter{}
*/
class GrandFather{
public void show(){
System.out.println(“我是爷爷”);
}
}

class Father extends GrandFather{
public void show1(){
System.out.println(“我是爸爸”);
}
}

class Son extends Father{
public void show2(){
System.out.println(“我是陈小康”);
}
}

class ExtendsDemo2{
public static void main(String [] args){
// 创建对象
Son s = new Son();
s.show();
s.show1();
s.show2();
}
}
----------------------------------------知识点11--------------------------------------------------
/*
继承的注意事项：
1.子类只能继承父类所有的非私有成员（成员方法和成员变量）
2.子类不能继承父类的构造方法，但是可以通过super关键字去访问谷类构造方法
3.不要为了部分功能就去继承

继承其实体现的是一种：“is a”。的关系

*/

class Father{
private int num = 10;
public int num2 = 20;

// 私有方法，子类不能继承
private void method(){
	System.out.println(num);
	System.out.println(num2);
}

public void show(){
	System.out.println(num);
	System.out.println(num2);
}

}
class Son extends Father{
public void function(){
//System.out.println(num);
//System.out.println(num2);
}
}
class ExtendsDemo3{
public static void main(String [] args){
// 创建对象
Son s = new Son();
// System.out.println(s.num); //子类不能继承父类的私有变量
System.out.println(s.num2);
//s.show();
//s.method(); // 子类不能继承父类的私有方法
//s.function();
}
}
----------------------------------------知识点12--------------------------------------------------
/*
类的组成：
成员变量：
构造方法：
成员方法：
而我们有讲解了继承，所以我们来考虑一下，类的组成部分的各自关系。

继承中的成员变量的关系
	1.子类中的成员变量和父类中的成员变量不同
	2.子类中的成员变量和父类相同，采用就近原则。
		在子类中访问成员变量的顺序
			1.在子类方法的局部范围内查找，有就使用
			2.在子类成员中查找，有就使用
			3.在父类的成员变量中查找，有就使用
			4.如果还找不到就报错

*/

class Father{
public int num =10;
}

class Son extends Father{
public int num2 = 20;
public void show(){
System.out.println(num);
System.out.println(num2);
}
}

class ExtendsDemo4{
public static void main(String [] args){
// 创建对象
Son s = new Son();
s.show();

}

}
----------------------------------------知识点13--------------------------------------------------
/*
问题是:我不仅要输出局部范围的num，还有输出本类成员范围的num，怎么办？
我还想要输出父类成员范围的num。怎么办呢，
如果有一个和this相似的关键字，直接访问父类的数据。

this和super的区别
	this 代表本类对应的引用
	super代表父类的存储空间的标识（可以理解为父类的引用，可以操作父类的成员）

super使用方法：
	调用成员变量：
		this.成员变量   调用本类中的成员变量
		super.成员变量  调用父类中的成员变量
	调用构造方法：
		this(...)  调用本类中的构造方法
		super(...) 调用父类中的构造方法
	调用成员方法：
		this.成员方法 调用本类中的成员方法
		super.成员方法 调用父类中的成员方法

*/

class Father{
public int num =10;
}

class Son extends Father{
public int num = 20;
public void show(){
int num = 30; // public int num = 30; 这个表达式错误的，在方法内部的是局部变量，不是成员变量
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}

}

class ExtendsDemo5{
public static void main(String [] args){
// 创建对象
Son s = new Son();
s.show();
}

}
----------------------------------------知识点14--------------------------------------------------
/*
集成中构造方法的关系
1.子类中所有的构造方法默认都会访问父类中空参数的构造方法
2.为什么所有子类构造方法都会访问父类的空参构造方法?
因为子类会继承父类中的数据，一定要先完成父类数据的初始化
所以，子类初始化之前，一定要完成父类数据类型的初始化

注意：子类的构造方法默认第一条语句是 super();

*/
class Father{
public Father(){
System.out.println(“Father的无参构造方法”);
}

public Father(String name){
	System.out.println("Father的有参构造方法");
}

}

class Son extends Father{
public Son(){
System.out.println(“Son的无参构造方法”);
}

public Son(String name){
	System.out.println("Son的有参构造方法");
}

}

class ExtendsDemo6{
public static void main(String [] args){
// 创建对象、
Son s = new Son();

	Son s1 = new Son("林青霞");
}

}
----------------------------------------知识点15--------------------------------------------------
/*
如果父类中没有无参构造方法，子类的构造方法会出现什么样的现象？
1.在父类中加一个无参构造方法
2.通过使用super关键字调用父类的构造方法
3.子类通过this调用本类的其他方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化

	注意事项 ：
		this (...)或者super(...)必须出现在第一条语句上
		如果不是放在第一条语句上，就可能对父类的数据进行多次初始化
		所以必须放在第一条语句上。

*/

class Father{
/public Father(){
System.out.println(“Father无参数构造方法”);
}/

public Father(String name){
	System.out.println("Father的有参构造方法");
}

}

class Son extends Father{
public Son(){
super(“林青霞”);
System.out.println(“Son的无参数构造方法”);
}

public Son(String name){
	//super("林青霞");
	this();
	System.out.println("Son的有参构造方法");
}

}

class ExtendsDemo7{
public static void main(String [] args){
Son s = new Son();
System.out.println("-------------");
Son ss = new Son(“林青霞”);
}
}
----------------------------------------知识点16--------------------------------------------------
/*
继承中成员方法的关系：
1.子类中的方法和父类的方法声明不一样
2.子类中的方法和父类中方法声明一样，该怎么办

		通过子类调用方法：
		a.先找子类中，看有没有该方法，有就使用
		b.再找父类中，有没有该方法，有就使用

*/

class Father{
public void show(){
System.out.println(“show Father”);
}
}

class Son extends Father{
public void method(){
System.out.println(“method Son”);
}

public void show(){
	System.out.println("show Son");
}

}

class ExtendsDemo8{
public static void main(String [] args){
// 创建对象
Son s = new Son();
s.method();
s.show();

}

}
----------------------------------------知识点17--------------------------------------------------
/*
方法重写：子类中出现了和父类声明方法一模一样。
也被称为方法覆盖，方法重写

方法重载：
	本类中出现的方法名一样，参数列表不同的方法，与返回值无关
	
子类对象调用方法本身的时候：
	先找子类本身，再找父类。

方法重写的应用：
	当子类需要父类的功能，而功能主体子类有自己特定的内容时，可以重写父类中的方法
	这样，即沿袭了父类的功能，又定义了子类的特有内容。

案例：
	1.定义一个手机类
	2.通过研究，发明了一个新手机，这个手机作用是打完电话，可以听天气预报
	
注意：使用super关键字去访问父类的成员方法

*/
class Phone{
public void call(String name){
System.out.println(“给”+name+“打电话”);
}
}

class NewPhone{
public void call(String name){
super.call(name);
//System.out.println(“给”+name+“打电话”);
System.out.println(“播报天气预报”);
}
}

class ExtendsDemo9{
public static void main(String [] argts){
// 创建对象
NewPhone p = new NewPhone();
p.call(“林青霞”);

}

}
----------------------------------------知识点18--------------------------------------------------
/*
方法重写的注意事项
1.父类中的私有方法不能被重写
因为父类私有方法子类无法继承
2.子类重写父类方法时，访问权限不能更低
最好一致
3.父类静态方法，子类必须通过静态方法重写
*/
class Father{
public void show(){
System.out.println(“Father show”);
}

 static void method(){
	System.out.println("Son method");
}

}

class Son extends Father{
public void show(){
System.out.println(“Son show”);
}

public static void method(){
	System.out.println("Son method");
}

}

class ExtendsDemo10{
public static void mian(){
// 创建对象
Son s = new Son();
s.show();
}

}
----------------------------------------知识点19--------------------------------------------------
/*
学生案例和老师案例讲解

学生：
	成员变量：姓名 年龄
	构造方法：无参 带参
	成员方法：getXxx() setXxx()
	
老师：
	成员变量：姓名 年龄
	构造方法：无参 带参
	成员方法： getXxx() setXxx()

*/
class Person{
//姓名
private String name;

// 年龄
private int age;

//无参构造方法
public Person(){
	System.out.println("Person 无参构造方法");
}

//带参构造方法
public Person(String name,int age){
	this.name = name;
	this.age = age;
	System.out.println("Person 带参构造方法");
}

//设置姓名方法
public void setName(String name){
	this.name = name;
}

//获取姓名方法
public String getName(){
	return name;
}

// 设置年龄方法
public void setAge(int age){
	this.age = age;
}

// 获取年龄方法
public int getAge(){
	return age;
}

}
// 继承Person类，产生Student类
class Student extends Person{
// super.Person(“tfboy”) 是错误表达格式
public Student(){}

public Student(String name,int age){
	//this.name = name;
	//this.age = age;
	super(name,age);
	
}

}

//继承Person类，产生Teacher类
class Teacher extends Person{
public Teacher(){}

public Teacher(String name,int age){
	//this.name =name;
	//this.age = age;
	super(name,age);
}

}

class ExtendsTest1{
public static void main(String [] args){
// 创建学生对象
//方式1
Student s = new Student();
s.setName(“蔡徐坤”);
s.setAge(20);
System.out.println(s.getName()+"—"+s.getAge());
System.out.println("-------------------");
//方式2
Student s2 = new Student(“蔡徐坤”,20);
System.out.println(s2.getName()+"—"+s2.getAge());
System.out.println("-------------------");

//创建老师对象
//方式1
Teacher t  = new Teacher();
t.setName("周杰伦");
t.setAge(30);
System.out.println(t.getName()+"---"+t.getAge());
System.out.println("-------------------");
//方式2
Teacher t2 = new Teacher("周杰伦",30);
System.out.println(t2.getName()+"---"+t2.getAge());
}

}
----------------------------------------知识点20--------------------------------------------------
/*
猫狗案例
分析：
猫类：
成员变量：颜色 重量 高度 叫声
构造方法：带参 无参
成员方法：setXxx() getXxx()
eat();
playGame();

	狗类：
		成员变量：颜色 重量 高度 叫声
		构造方法：带参 无参
		成员方法：setXxx() getXxx()
				  eat();
				  lookDoor();

*/

class Animal{
//颜色
private String color;
//重量
private int weight;
//高度
private int height;
// 叫声
private String bark;

// 无参构造方法 作为父类，子类的构造方法初始化默认为无参构造方法
public Animal(){
	System.out.println("Animal 的无参构造方法");
}

//带参构造方法
public Animal(String color,int weight,int height,String bark){
	this.color = color;
	this.weight = weight;
	this.height = height;
	this.bark = bark;
}

//设置颜色方法
public void setColor(String color){
	this.color = color;
}
//获取颜色方法
public String getColor(){
	return color;
}

//设置重量方法
public void setWeight(int weight){
	this.weight = weight;
}
//获取重量方法
public int getWeight(){
	return weight;
}

//设置高度方法
public void setHeight(int height){
	this.height = height;
}
//获取高度方法
public int getHeight(){
	return height;
}

//设置叫声方法
public void setBark(String bark){
	this.bark = bark;
}
public String getBark(){
	return bark;
}

//eat()方法
public void eat(){
	System.out.println("吃东西");
}

}

// 创建猫对象
class Cat extends Animal{
// 无参构造方法
public Cat(){}

//带参构造方法
public Cat(String color,int weight,int height,String bark){
	super(color,weight,height,bark);
}
// playGame方法
public void playGame(){
	System.out.println("喵星人玩游戏");
}

}

// 创建狗类
class Dog extends Animal{
// 无参构造方法
public Dog(){}

//带参构造方法
public Dog(String color,int weight,int height,String bark){
	super(color,weight,height,bark);
	//super.color = color;
	//super.weight  = weight; // color等是私有成员变量只能在本类中访问
	//super.height = height;
	//super.bark = bark;
}

// lookDoor方法
public void lookDoor(){
	System.out.println("汪星人看门");
}

}

// 测试代码
class ExtendsTest2{
public static void main(String [] args){
// 创建猫对象
// 方式1
Cat c = new Cat();
c.setColor(“白色”);
c.setWeight(5);
c.setHeight(8);
c.setBark(“喵喵”);
System.out.println(“我是一只喵星人:”+c.getColor()+" “+c.getWeight()+” “+c.getHeight()+” “+c.getBark());
c.eat();
c.playGame();
System.out.println(”----------------------------");

// 方式2
Cat c2 = new Cat("黄色",5,8,"喵喵");
System.out.println("我是一只喵星人:"+c2.getColor()+" "+c2.getWeight()+" "+c2.getHeight()+" "+c2.getBark());
c2.eat();
c2.playGame();
System.out.println("----------------------------");

// 创建狗对象
// 方式1
Dog d = new Dog();
d.setColor("黄色");
d.setWeight(15);
d.setHeight(10);
d.setBark("汪汪");
System.out.println("我是一只汪星人:"+d.getColor()+" "+d.getWeight()+" "+d.getHeight()+" "+d.getBark());
d.eat();
d.lookDoor();
System.out.println("----------------------------");

// 方式2
Dog d2 = new Dog("黄色",15,10,"汪汪");
System.out.println("我是一只汪星人:"+d2.getColor()+" "+d2.getWeight()+" "+d2.getHeight()+" "+d2.getBark());
d2.eat();
d2.lookDoor();
System.out.println("----------------------------");
}

}
----------------------------------------知识点21--------------------------------------------------
1.方法重写和方法重载的区别？方法重载能改变返回值吗？
方法重写：在子类中出现了和父类一模一样的方法声明，
参数列表返回值类型均相同

方法重载：在同一个类中，出现了方法名相同，参数列表不同的现象，
			与返回值类型无关

方法重载能够改变返回值类型，因为它和返回值类型无关。

Override 方法重写
Overload 方法重载

2.this关键字和super关键字分别代表什么？以及他们各自的使用场景

this：代表当前类的对象
super：代表父类存储空间标识(可理解为父类的引用，可以访问父类成员)

场景：
成员变量：
this.成员变量
super.成员变量
构造方法：
this(…)
super(…)
成员方法：
this.成员方法
super.成员方法