[学习交流] 【阳哥笔记】极速秒杀Java基础之笔记系列—Day08（继承）！

luklon

笔记总链接：http://bbs.itheima.com/thread-200600-1-1.html

3、面向对象

3.7 数组工具类

示例：

public class ArrayTool{
//该类中的方法都是静态的，所以该类是不需要创造对象的
//为了保证不让他人创建该类对象，可以将构造函数私有化
private ArrayTool(){}
//获取整型数组的最大值
public static int getMax(int[] arr){
int maxIndex = 0;
for(int x = 1; x < arr.length; x++){
if(arr[x] > arr[maxIndex])
maxIndex = x;
}
return arr[maxIndex];
}
//对数组进行选择排序
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[x] > arr[y])
swap(arr,x,y);
}
}
}
//用于给数组进行元素的位置置换。
private static void swap(int[] arr, int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//获取指定的元素在指定数组中的索引
public static int getIndex(int[] arr, int key){
for(int x = 0; x < arr.length; x++){
if(arr[x] == key)
return x;
}
return -1;
}
//将int 数组转换成字符串，格式是：[e1,e2,...]
public static String arrayToString(int[] arr){
String str = "[";
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
str = str + arr[x] + ",";
else
str = str + arr[x] + "]";
}
return str;
}
}
class ArrayToolDemo{
//保证程序的独立运行
public static void main(String[] args){
int[] arr = {4,8,2,9,7,72,6};
int max = ArrayTool.getMax(arr);
System.out.println("max = " + max);
int index = ArrayTool.getIndex(arr,10);
System.out.println("index = " + index);
}
}

复制代码

运行结果：

3.10 文档注释

示例：

/**
* 建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数，如：最值，排序等。
* @author 张三
* @version v1.0
*/
public class ArrayTool{
private ArrayTool(){}
/**
* 获取整型数组的最大值
* @param arr 接收一个元素为int 类型的数组
* @Return 该数组的最大的元素值
*/
public static int getMax(int[] arr){
int maxIndex = 0;
for(int x = 1; x < arr.length; x++){
if(arr[x] > arr[maxIndex])
maxIndex = x;
}
return arr[maxIndex];
}
/**
* 对数组进行选择排序
* @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[x] > arr[y])
swap(arr,x,y);
}
}
}
//用于给数组进行元素的位置置换。
private static void swap(int[] arr, int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
* 获取指定的元素在指定数组中的索引
* @param arr 接收一个元素为int 类型的数组
* @param key 要找的元素
* @return 返回该元素第一次出现的位置，如果不存在则返回 -1
*/
public static int getIndex(int[] arr, int key){
for(int x = 0; x < arr.length; x++){
if(arr[x] == key)
return x;
}
return -1;
}
/**
* 将int数组转换成字符串，格式是：[e1,e2,...]
* @param arr 接收一个元素为int类型的数组
* @return 返回该数组的字符串表现形式
*/
public static String arrayToString(int[] arr){
String str = "[";
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
str = str + arr[x] + ",";
else
str = str + arr[x] + "]";
}
return str;
}
}

复制代码

运行结果：

P.S.

1、如果想把一个类进行文档化，该类必须是public的。

2、私有的方法在文档中不会体现，例如ArrayTool类中的swap方法。

3.11 单例设计模式

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

单例设计模式解决的问题：就是可以保证一个类在内存中的对象唯一性。
比如多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？
1、不允许其他程序用new创建该类对象。
2、在该类创建一个本类实例。
3、对外提供一个方法让其他程序可以获取该对象。

步骤：
1、私有化该类构造函数。
2、通过new在本类中创建一个本类对象。
3、定义一个公有的方法，将创建的对象返回。

示例（饿汉式）：

class Single{
//类已加载，对象就已经存在了
private static Single s = new Single();
private Single(){}
public static Single getInstance(){
return s ;
}
}
class SingleDemo{
public static void main(String[] args){
Single s1 = Single.getInstance();
Single s2 = Single. getInstance();
System.out.println(s1 == s2);
}
}

复制代码

运行结果：

P.S.
之所以不用Single.s;的方式获取Single对象，而采用getInstance获取是因为在getInstance方法中我们可以做一些判断来决定是否返回Single的对象，也就是实现了对单例对象的可控。所以，给Single的构造方法加上了private限制，禁止使用者直接采用Single.s;的方式获取。

示例（懒汉式）：

class Single{
//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象
//延迟加载形式
private static Single s = null;
private Single(){}
public static Single getInstance(){
if(s == null)
s = new Single();
return s ;
}
}
class SingleDemo{
public static void main(String[] args){
Single s1 = Single. getInstance();
Single s2 = Single. getInstance();
System.out.println(s1 == s2);
}
}

复制代码

运行结果：

4、继承

4.1 继承的描述

通过 extends 关键字让类与类之间产生继承关系。
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

P.S.
1、子类可以直接访问父类中的非私有的属性和行为。
2、子类无法继承父类中私有的内容。
3、父类怎么来的？共性不断向上抽取而来的。

示例：

class Person{
String name;
int age ;
}
class Student extends Person{
void study(){
System.out.println("student study..." + age);
}
}
class Worker extends Person{
void work(){
System.out.println("worker work..." + age);
}
}
class ExtendDemo{
public static void main(String[] args){
Student s = new Student();
s. name = "zhangsan" ;
s. age = 20;
s.study();
Worker w = new Worker();
w. name = "lisi" ;
w. age = 30;
w.work();
}
}

复制代码

运行结果：

好处：
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

4.2 继承的特点

Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。

原因：
因为多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。

示例：

class A{
void show(){
System.out.println("a" );
}
}
class B{
void show(){
System.out.println("b" );
}
}
class C extends B,A{
}

复制代码

那么创建类C的对象，调用show方法就不知道调用类A中的show方法还是类B中的show方法。所以java不支持多继承，但将这种机制换了另一个安全的方式来体现，也就是多实现（后面会详细说明）。

Java支持多层继承(继承体系)：
C继承B，B继承A，就会出现继承体系。
多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。

定义继承需要注意：
不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( "is a")关系。

4.3 super关键字&函数覆盖

在子父类中，成员的特点体现：

1. 成员变量
      this和super的用法很相似。
      this代表本类对象的引用。
      super代表父类的内存空间的标识。

      当本类的成员和局部变量同名用this区分。
      当子父类中的成员变量同名用super区分父类。

示例：

class Fu{
private int num = 4;
public int getNum(){
return num ;
}
}
class Zi extends Fu{
private int num = 5;
void show(){
System.out.println(this.num + "..." + super.getNum());
}
}
class ExtendDemo{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}

复制代码

运行结果：

2. 成员函数
      当子父类中出现成员函数一模一样的情况，会运行子类的函数。
      这种现象，称为覆盖操作，这是函数在子父类中的特性。
      在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

函数两个特性：
1. 重载，同一个类中。
2. 覆盖，子类中，覆盖也称为重写，覆写，override。

示例：

class Fu{
public void show(){
System.out.println("fu show run" );
}
}
class Zi extends Fu{
public void show(){
System.out.println("zi show run" );
}
}
class ExtendDemo{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}

复制代码

运行结果：

什么时候使用覆盖操作？
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

示例：

class Phone{
void call(){}
void show(){
System.out.println("number" );
}
}
class NewPhone extends Phone{
void show(){
System.out.println("name" );
System.out.println("pic" );
super.show();
}
}
class ExtendDemo{
public static void main(String[] args){
NewPhone p = new NewPhone();
p.show();
}
}

复制代码

运行结果：

P.S.
1、父类中的私有方法不可以被覆盖。
2、父类为static的方法无法覆盖。
3、覆盖时，子类方法权限一定要大于等于父类方法权限。

示例：

class Fu{
public void show(){
System.out.println("fu show run" );
}
}
class Zi extends Fu{
private void show(){
System.out.println("zi show run" );
}
}
class ExtendDemo{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}

复制代码

运行结果：

3. 构造函数

      子父类中构造函数的特点：
      在子类构造函数执行时，发现父类构造函数也运行了。
      原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();。
      注意：如果使用super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。

示例：

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{
Zi(){
//super();//默认调用的就是父类中的空参数的构造函数
System.out.println("C zi run " + num);
}
Zi(int x){
super(4);
System.out.println("D zi run " + x);
}
}
class ExtendDemo{
public static void main(String[] args){
new Zi();
System.out.println("-------------------" );
new Zi(6);
}
}

复制代码

运行结果：

~END~

~爱上海，爱黑马~

houzhiming · houzhiming

谢谢楼主分享。

青春young · 青春young

笔记很给力，一直看强哥的笔记在学习

lixy · lixy

这些笔记应该都是按上课的节奏总结的吧

szb · szb

学习中加油

tanker · tanker

加油加油，顶

再续啸傲 · 再续啸傲

get and look look

胡薇健 · 胡薇健

好笔记，楼主威武

liuyang10908126 · liuyang10908126

总结的很到位！

马永飞 · 马永飞

黑马越办越好

1277886228

支持！

liying · liying

阳哥威武

梁名扬 · 梁名扬

这笔记给力啊

wx_URVMBbXs · wx_URVMBbXs

收益了谢谢分享

yqlbd · yqlbd

再次复习笔记，加深映像。

毕静存 · 毕静存

顶起!!!!!!!!!!!!!!!

czcjyqm · czcjyqm

看了之后收获好多

石三伢子1 · 石三伢子1

笔记，简洁干练，几乎涵盖了全部易错点和重点，流程过度舒缓，逻辑顺畅；顶！

1975532882

牛叉，，，，，，，，，

307117758

阳哥屌啊！

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【阳哥笔记】极速秒杀Java基础之笔记系列—Day08（继承）！

点评

70 个回复