Java基础-08(01)总结帮助文档,代码块,继承

1:如何制作帮助文档(了解)

(1)写一个类

(2)加入文档注释

(3)通过javadoc工具生成即可

javadoc -d 目录 -author -version ArrayTool.java

/*
 我想要对数组进行操作
 在同一个文件夹下,类定义在两个文件中和定义在一个文件中其实一样的。
*/
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;
 }
}

2:通过JDK提供的API学习了Math类(掌握)

(1)API(Application Programming Interface)

应用程序编程接口(帮助文档)

(2)如何使用呢?

请参照

day08\code\02_如何使用JDK提供的帮助文档\如何使用帮助文档.txt

(3)Math类

A:是针对数学进行操作的类

B:没有构造方法,因为它的成员都是静态的

C:产生随机数

public static double random(): [0.0,1.0)

D:如何产生一个1-100之间的随机数

int number = (int)(Math.random()*100)+1;

E:猜数字小游戏

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

3:代码块(理解)

(1)用{}括起来的代码。

(2)分类:

A:局部代码块

用于限定变量的生命周期,及早释放,提高内存利用率。

B:构造代码块

把多个构造方法中相同的代码可以放到这里,每个构造方法执行前,首先执行构造代码块。

C:静态代码块

对类的数据进行初始化,仅仅只执行一次。

(3)静态代码块,构造代码块,构造方法的顺序问题?

静态代码块 > 构造代码块 > 构造方法

/*
 代码块:在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();
 }
}

4:继承(掌握)

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系,

这多个类就具备了这些内容。这个关系叫继承。

(2)Java中如何表示继承呢?格式是什么呢?

A:用关键字extends表示

B:格式:

class 子类名 extends 父类名 {}

(3)继承的好处:

A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类产生了一个关系,是多态的前提

(4)继承的弊端:

A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。

原则:低耦合,高内聚。

耦合:类与类的关系

内聚:自己完成某件事情的能力

B:打破了封装性

/*
 继承概述:
 把多个类中相同的内容给提取出来定义到一个类中。
 如何实现继承呢? 
 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();
 }
}

(5)Java中继承的特点

A:Java中类只支持单继承

B:Java中可以多层(重)继承(继承体系)

/*
 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(); //使用爷爷的
 }
}

(6)继承的注意事项:

A:子类不能继承父类的私有成员

B:子类不能继承父类的构造方法,但是可以通过super去访问

C:不要为了部分功能而去继承

/*
 继承的注意事项:
 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();
 }
}

(7)什么时候使用继承呢?

A:继承体现的是:is a的关系。

B:采用假设法

(8)Java继承中的成员关系

A:成员变量

a:子类的成员变量名称和父类中的成员变量名称不一样,这个太简单

b:子类的成员变量名称和父类中的成员变量名称一样,这个怎么访问呢?

子类的方法访问变量的查找顺序:

在子类方法的局部范围找,有就使用。

在子类的成员范围找,有就使用。

在父类的成员范围找,有就使用。

找不到,就报错。

B:构造方法

a:子类的构造方法默认会去访问父类的无参构造方法

是为了子类访问父类数据的初始化

b:父类中如果没有无参构造方法,怎么办?

子类通过super去明确调用带参构造

子类通过this调用本身的其他构造,但是一定会有一个去访问了父类的构造

让父类提供无参构造

C:成员方法

a:子类的成员方法和父类中的成员方法名称不一样,这个太简单

b:子类的成员方法和父类中的成员方法名称一样,这个怎么访问呢?

通过子类对象访问一个方法的查找顺序:

在子类中找,有就使用

在父类中找,有就使用

找不到,就报错

/*
 类的组成:
 成员变量:
 构造方法:
 成员方法:
 而现在我们又讲解了继承,所以,我们就应该来考虑一下,类的组成部分的各自关系。
 继承中成员变量的关系:
 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();
 }
}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2016-11-28

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Jed的技术阶梯

详解 Java 对象与内存控制(上)

不管是类变量还是实例变量,你都不能引用一个还没有定义的变量,或者在引用之前没有定义的变量,如下图所示:

12230
来自专栏一“技”之长

Swift中构造方法的解析 原

      构造方法是一个类创建对象最先也是必须调用的方法,在Objective-C中,开发者更习惯称这类方法为初始化方法。在Objective-C中的初始化方...

9320
来自专栏Python研发

javascript作用域

javascript的作用域一直以来是前端开发中比较难理解的知识点,对于javascript的作用域主要记住几句话.

10320
来自专栏菩提树下的杨过

scala 学习笔记(07) 一等公民的函数

在scala中一切皆对象,一切皆函数,函数跟Int,String、Class等其它类型是处于同等的地位,换句话说,使用函数跟使用普通的类型一样,没什么区别,因此...

20370
来自专栏Kevin-ZhangCG

排序算法总结

18730
来自专栏Python爱好者

Java基础笔记08

14350
来自专栏我是业余自学C/C++的

纯虚函数

18020
来自专栏用户2442861的专栏

java中的内部类总结

http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html

9630
来自专栏鸿的学习笔记

Scala的函数

前文已经提到Scala变量的用法,现在聊聊函数。在Scala里,函数的定义很简单。例如:

8910
来自专栏转载gongluck的CSDN博客

前缀、中缀、后缀表达式

它们都是对表达式的记法,因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同:前缀表达式的运算符位于与其相关的操作数之前;...

43690

扫码关注云+社区

领取腾讯云代金券