Java基础-08（01）总结帮助文档，代码块，继承

/*
 我想要对数组进行操作
 在同一个文件夹下，类定义在两个文件中和定义在一个文件中其实一样的。
*/
class ArrayDemo {
 public static void main(String[] args) {
 //定义数组
 int[] arr = {28,55,37,46,19};
 //需求：遍历数组
 /*
 for(int x=0; x<arr.length; x++) {
 if(x == arr.length-1) {
 System.out.println(arr[x]);
 }else {
 System.out.print(arr[x]+", ");
 }
 }
 */
 //如果我有多个数组都要进行遍历，那么，代码的重复度就很高
 //如何改进呢?用方法改进
 //调用
 //静态方法
 //printArray(arr);
 //非静态方法
 //ArrayDemo ad = new ArrayDemo();
 //ad.printArray(arr);
 //测试类的作用：创建其他类的对象，调用其他类的功能。
 //而我们现在的操作是跟数组相关的，所以，你应该把这些操作定义到数组操作类中
 //定义一个数组的操作类
 //有了数组操作类之后的调用
 //ArrayTool at = new ArrayTool();
 //at.printArray(arr);
 //方法改进为静态后，就可以直接通过类名调用
 ArrayTool.printArray(arr);
 }
 /*
 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]+", ");
 }
 }
 }
 */
 //假设该方法不是静态的
 /*
 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]+", ");
 }
 }
 }
 */
}
lass 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]+", ");
 }
 }
 }
}
/*
 我想要对数组进行操作
 如何制作一个说明书呢?
 A:写一个工具类
 B:对这个类加入文档注释
 怎么加呢?
 加些什么东西呢?
 C:用工具解析文档注释
 javadoc工具
 D:格式
 javadoc -d 目录 -author -version ArrayTool.java
 目录：就可以写一个文件夹的路径
 制作帮助文档出错：
 找不到可以文档化的公共或受保护的类：告诉我们类的权限不够
*/
class ArrayDemo {
 public static void main(String[] args) {
 //定义数组
 int[] arr = {28,55,37,46,19};
 //遍历
 ArrayTool.printArray(arr);
 //获取最值
 int max = ArrayTool.getMax(arr);
 System.out.println("max:"+max);
 //获取55的索引值
 int index = ArrayTool.getIndex(arr,55);
 System.out.println("index:"+index);
 }
}
/**
* 这是针对数组进行操作的工具类
* @author 刘意
* @version V.10
*/
public class ArrayTool {
 //把构造方法私有，外界就不能在创建对象了
 /**
 * 这是私有构造
 */
 private ArrayTool(){}
 /**
 * 这是遍历数组的方法，遍历后的格式是：[元素1, 元素2, 元素3, ...]
 * @param arr 这是要被遍历的数组
 */
 public static void printArray(int[] arr) {
 System.out.print("[");
 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 返回元素在数组中的索引，如果不存在，返回-1
 */
 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;
 }
}

/*
 Math:类包含用于执行基本数学运算的方法
 由于Math类在java.lang包下，所以不需要导包。
 特点：
 没有构造方法，因为它的成员全部是静态的。
 掌握一个方法：
 获取随机数
 public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
*/
class MathDemo {
 public static void main(String[] args) {
 //获取一个随机数
 //double d = Math.random();
 //System.out.println(d);
 //需求：我要获取一个1-100之间的随机数，肿么办?
 for(int x=0; x<100; x++) {
 int number = (int)(Math.random()*100)+1;
 System.out.println(number);
 }
 }
}
/*
 猜数字小游戏(数据在1-100之间)
 分析：
 A:程序产生一个随机数。(被猜的)
 B:键盘录入数据。(你猜的)
 C:把你猜的和被猜的进行比较
 a:大了
 b:小了
 c:猜中了
 D:给出多次猜的机会，猜中就结束。
 while()循环，猜中就break
*/
import java.util.Scanner;
class GuessNumber {
 public static void main(String[] args) {
 //程序产生一个随机数。(被猜的)
 int number = (int)(Math.random()*100)+1;
 //System.out.println(number);
 //给出多次猜的机会，猜中就结束。
 while(true) {
 //键盘录入数据。(你猜的)
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入你要猜的数据(1-100):");
 int guessNumber = sc.nextInt();
 //把你猜的和被猜的进行比较
 if(guessNumber > number) {
 System.out.println("你猜的数据"+guessNumber+"大了");
 }else if(guessNumber < number) {
 System.out.println("你猜的数据"+guessNumber+"小了");
 }else {
 System.out.println("恭喜你，猜中了");
 break;
 }
 }
 }
}

/*
 代码块：在Java中，使用{}括起来的代码被称为代码块。
 根据其位置和声明的不同，可以分为
 局部代码块:局部位置,用于限定变量的生命周期。
 构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
 作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
 静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
 作用：一般是对类进行初始化。
 面试题?
 静态代码块,构造代码块,构造方法的执行顺序?
 静态代码块 -- 构造代码块 -- 构造方法
 静态代码块：只执行一次
 构造代码块：每次调用构造方法都执行
*/
class Code {
 static {
 int a = 1000;
 System.out.println(a);
 }
 //构造代码块
 {
 int x = 100;
 System.out.println(x);
 }
 //构造方法
 public Code(){
 System.out.println("code");
 }
 //构造方法
 public Code(int a){
 System.out.println("code");
 }
 //构造代码块
 {
 int y = 200;
 System.out.println(y);
 }
 //静态代码块
 static {
 int b = 2000;
 System.out.println(b);
 }
}
class CodeDemo {
 public static void main(String[] args) {
 //局部代码块
 {
 int x = 10;
 System.out.println(x);
 }
 //找不到符号
 //System.out.println(x);
 {
 int y = 20;
 System.out.println(y);
 }
 System.out.println("---------------");
 Code c = new Code(); 
 System.out.println("---------------");
 Code c2 = new Code();
 System.out.println("---------------");
 Code c3 = new Code(1);
 }
}
/*
 写程序的执行结果。
 林青霞都60了，我很伤心
 我是main方法
 Student 静态代码块
 Student 构造代码块
 Student 构造方法
 Student 构造代码块
 Student 构造方法
*/
class Student {
 static {
 System.out.println("Student 静态代码块");
 }
 {
 System.out.println("Student 构造代码块");
 }
 public Student() {
 System.out.println("Student 构造方法");
 }
}
class StudentDemo {
 static {
 System.out.println("林青霞都60了，我很伤心");
 }
 public static void main(String[] args) {
 System.out.println("我是main方法");
 Student s1 = new Student();
 Student s2 = new Student();
 }
}

/*
 继承概述：
 把多个类中相同的内容给提取出来定义到一个类中。
 如何实现继承呢? 
 Java提供了关键字：extends
 格式：
 class 子类名 extends 父类名 {}
 好处：
 A:提高了代码的复用性
 B:提高了代码的维护性
 C:让类与类之间产生了关系，是多态的前提
 类与类产生了关系，其实也是继承的一个弊端：
 类的耦合性增强了。
 开发的原则：低耦合，高内聚。
 耦合：类与类的关系
 内聚：就是自己完成某件事情的能力
*/
//使用继承前
/*
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();
 }
}

/*
 Java中继承的特点：
 A:Java只支持单继承，不支持多继承。
 有些语言是支持多继承，格式：extends 类1,类2,...
 B:Java支持多层继承(继承体系)
*/
/*
class Father {}
class Mother {}
class Son exnteds Father {} //正确的
class Son extends Father,Mother {} // 错误的
*/
class GrandFather {
 public void show() {
 System.out.println("我是爷爷");
 }
}
class Father extends GrandFather {
 public void method(){
 System.out.println("我是老子");
 }
}
class Son extends Father {}
class ExtendsDemo2 {
 public static void main(String[] args) {
 Son s = new Son();
 s.method(); //使用父亲的
 s.show(); //使用爷爷的
 }
}

/*
 继承的注意事项：
 A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
 B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
 C:不要为了部分功能而去继承
 class A {
 public void show1(){}
 public void show2(){}
 }
 class B {
 public void show2(){}
 public void show3(){}
 }
 //我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现
 class B extends A {
 public void show3(){}
 }
 这样其实不好，因为这样你不但有了show2(),还多了show1()。
 有可能show1()不是你想要的。
 那么，我们什么时候考虑使用继承呢?
 继承其实体现的是一种关系："is a"。
 Person
 Student
 Teacher
 水果
 苹果
 香蕉
 橘子
 采用假设法。
 如果有两个类A,B。只有他们符合A是B的一种，或者B是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() {
 //num可以在Father中访问private
 //System.out.println(num); //子类不能继承父类的私有成员变量
 System.out.println(num2);
 }
}
class ExtendsDemo3 {
 public static void main(String[] args) {
 // 创建对象
 Son s = new Son();
 //s.method(); //子类不能继承父类的私有成员方法
 s.show();
 s.function();
 }
}

/*
 类的组成：
 成员变量：
 构造方法：
 成员方法：
 而现在我们又讲解了继承，所以，我们就应该来考虑一下，类的组成部分的各自关系。
 继承中成员变量的关系:
 A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。
 B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?
 在子类方法中访问一个变量的查找顺序：
 a:在子类方法的局部范围找，有就使用
 b:在子类的成员范围找，有就使用
 c:在父类的成员范围找，有就使用
 d:如果还找不到，就报错。
*/
class Father {
 public int num = 10;
 public void method() {
 int num = 50;
 }
}
class Son extends Father {
 public int num2 = 20;
 public int num = 30;
 public void show() {
 int num = 40;
 System.out.println(num);
 System.out.println(num2);
 // 找不到符号
 System.out.println(num3);
 }
}
class ExtendsDemo4 {
 public static void main(String[] args) {
 //创建对象
 Son s = new Son();
 s.show();
 }
}