Java基础(面向对象之继承和多态,抽象类,接口,数组的选择排序)

1.代码块

1.代码块的分类:

​ 局部代码块:在类中的方法中的代码块,作用:限定局部变量的生命周期;

​ 构造代码块: 在类中方法外定义的 用{}包裹起来的,作用:给类中的一些成员进行数据初始化特点:在执行构造方法之前,如果存在构造 代码块,那么先执行构造代码块中的内容;

​ 静态代码块: 使用static 修饰的代码块;特点:随着类的加载而加载,优先于对象存在;静态代码块在程序执行过程中只执行一次;

代码块的优先级: 静态代码块 > 构造代码块 > 局部代码块

2.如何产生文档-----html页面

打开dos控制台

进入指定目录下:javadoc -d 文件夹名称 -author -version java文件

2.this与super

this:代表当前类对象的地址值引用
super:代表的父类的空间标识(代表父类对象的地址值引用)

访问成员变量,成员方法,构造方法
成员变量:
this.变量名; 它的访问的是本类的成员变量
super.变量名; 访问父类的成员变量
成员方法:
this.方法名() ;访问本类的成员方法
super.方法名() ;访问父类的成员方法
构造方法:
this() ;访问的是本类的无参构造方法
super() ;访问的是父类的无参构造方法

this(具体值) ;访问的是本类的有参构造方法

super(具体值);访问的是父类的有参构造方法

3.继承

1.继承的概念

​ 将多个类的内容抽取到一个独立的类中,使得这多个类和这个独立的类产生一种关系------继承关系

2.继承的好处:

​ 1)提高代码的维护性;

​ 2)提高代码的复用性;

​ 3)让类与类之间产生联系时产生多态的必要条件

2.继承的特点

1)类与类之间只能单继承,不能多继承;

2)可以多层继承

3.使用继承的注意事项

1)子类继承父类,可以继承父类中所有的非私有属性和非私有方法,但是私有的成员可以通过公共访问方法进行访问;

2)构造方法是不能被继承的,但是子类可以通过super间接访问父类的构造方法

4.继承中每个成员变量的关系

1)子类继承父类,如果子类的成员变量名称和父类成员变量名称不一致,分别访问即可;

2)如果子类的成员变量名称与父类成员变量名称一致

​ a)先在子类中找,如果有就使用;

​ b)如果没有,再在父类的成员变量中寻找,如果有就使用,如果没有就报错

5.继承中构造方法的访问

1)子类继承父类,子类所有的构造方法都会访问父类的无参构造方法;

2)父类中没有无参构造方法,那么子类会报错

解决方法;

​ 1)在父类中一直给出无参构造

​ 2)在子类构造方法中的第一句话通过super间接的访问父类的有参构造方法;

​ 3)只要在子类的构造方法中存在一个能够让父类初始化的方法即可

6.什么时候使用继承

不要为了部分功能而使用继承关系

正确使用继承关系:如果B类是A类的一种,这个时候就可以使用继承

继承关系的本质: 在现实世界事物中体现的是一种"is a"的关系

例1:

//定义一个手机类 :Phone
class Phone{
   
    //打电话
    public void call(){
   
        System.out.println("手机可以打电话...");
    }
}
//新的手机类
class NewPhone extends  Phone{
   

    //子类出现了和父类一模一样的方法声明:沿用打电话的功能,并且还需要提供新的功能
    public void call(){
   

        System.out.println("可以看天气预报了...") ;
        //沿用父类的功能
        super.call();

        System.out.println("还可以听音乐...") ;
    }
}
//测试类
public class ExtendsDemo2 {
   
    public static void main(String[] args) {
   
            //创建子类对象
        NewPhone np = new NewPhone() ;
        np.call();
    }

例2:

设计一个台灯类(Lamp)其中台灯有灯泡类(Buble)这个属性，还有开灯(on)这个方法。

设计一个灯泡类(Buble)，灯泡类有发亮的方法(shine)，

其中有红灯泡类(RedBuble)和绿灯泡类(GreenBuble)

他们都继承灯泡类(Buble)一个发亮的方法

//设计一个台灯类(Lamp)其中台灯有灯泡类(Buble)这个属性，还有开灯(on)这个方法。
public class Lamp {
   
    //成员变量
    Buble buble ;//灯泡类属性

    //开灯---灯泡发亮?
    //开灯的方法
    public void on(Buble buble){
    //形式参数---传递的是一个类--调用on方法,需要创建灯泡类对象
        buble.shine() ;

    }
}
//设计一个灯泡类(Buble)，灯泡类有发亮的方法(shine)，
//其中有红灯泡类(RedBuble)和绿灯泡类(GreenBuble)
public class Buble {
   
    //灯泡发亮的方法
    public void shine() {
   
        System.out.println("灯泡可以发亮了...");
    }
  
}
//绿灯泡
public class GreenBuble extends Buble {
   
    @Override
    public void shine() {
   
        super.shine();
        System.out.println("而且还可以发绿光");
    }
}
//红灯泡
public class RedBuble extends Buble {
   
    @Override
    public void shine() {
   
        super.shine();
        System.out.println("而且发的还是红光...");
    }
}
//测试类
public class Test2 {
   
    public static void main(String[] args) {
   

        //创建台灯类对象
        Lamp lamp = new Lamp() ;
        //调用开灯
        RedBuble redBuble = new RedBuble() ;
        lamp.on(redBuble); 
        System.out.println("---------------------------");
        lamp.on(new RedBuble());
        System.out.println("====================================");
        GreenBuble greenBuble = new GreenBuble() ;
        lamp.on(greenBuble);
        lamp.on(new GreenBuble());

    }
}

4.多态

多态就是一种事物在不停时刻的不同状态

1.多态的前提条件:

​ 1)必须存在继承关系;

​ 2)必须存在方法重写;

​ 3)必须有父类引用指向子类对象

2.多态的成员访问特点:

​ 1)针对成员变量的访问问题: 编译看左,运行看左;

​ 2)针对成员方法的访问问题:编译看左,运行看右;

​ 3)针对静态成员方法的访问问题:编译看左,运行看左;

​ 4)针对构造方法:分层初始化,先让父类初始化,再让子类初始化

3.多态的好处

1)提高了代码的复用性:由继承保证;

2)提高了代码的扩展性;由多态保证;

4.多态的弊端

不能访问子类的特有功能

解决方法:

​ 1)具体的子类创建具体的子类对象;(占用内存)

​ 2)使用向下转型;

向上转型: Fu f = new Zi;

向下转型: Zi zi = (Zi) f

5.多态使用向下转型时出现异常

要使用向下转型,前提是必须要有父类引用指向子类对象,心里要清楚堆内存存储的类型

向下转型使用不当就会出现java.lang.ClassCastException:类型转换异常(属于运行时期异常)

当堆内存中存储的实例不是该类型时,就会出现异常

5.final关键字

final是一个状态修饰符,意为最终的,无法更改的

final关键字的特点:

​ 1)可以修饰类,该类不能被继承

​ 2)修饰成员方法,该成员方法不能被重写;

​ 3)修饰一个变量,这个变量变为一个常量

final修饰基本数据类型和修饰引用数据类型的区别?

final修饰基本数据类型:基本数据类型的相应的数据值不能更改;

final修饰引用数据类型:引用数据类型对应的地址值不能被改变

6.方法重写与方法重载

1.方法重载:Overload
在一个类中,定义多个方法,这些方法的方法名相同,参数列表不同,与返回值无关;
参数列表:
1)数据类型不同
2)参数个数不同
3)先后顺序

重载的目的:为了提高功能的扩展性:同一个方法可以接收很多类型的参数

2.方法重写:Override
在继承关系中,子类出现了和父类一模一样的方法,这个子类将父类的功能覆盖(复写/重写),创建子类具体对象,
直接方法该功能,使用的子类的功能!

​ 重写的目的:为了沿用父类的功能,并且还需要使用子类的功能(具体的子类才具备具体的动作…)
​

7.抽象类

abstract关键字 : 抽象的含义

抽象类的宗旨就是强制子类必须完成父类中所有的抽象方法

1.抽象方法的格式:

权限修饰符 abstract 返回值类型 方法名(形式参数列表)

2.抽象类的格式

abstract class 类名{}

3.抽象方法的格式:

abstract void 方法名();

抽象方法不能有方法体

4.抽象类的特点:

1)有抽象方法的类一定是抽象类；

2)抽象类中不一定只有抽象方法，还可以有具体方法；

3)抽象类不能实例化,需要通过具体的子类进行实例化(创建对象);

4)抽象类的子类有两种情况:

​ a)如果抽象类的子类都是抽象类,那么就必须有一个能够让抽象类实例化的子类,否则这个抽象类就没有意义;

​ b)抽象类的子类是具体类,可以直接对抽象类进行实例化

5.抽象类的成员特点:

成员变量:既可以是变量,也可以是常量(被final修饰);

成员方法:既可以定义为抽象方法,也可以定义为非抽象方法;

​ 如果定义为抽象方法,用abstract显示给出;

构造方法:存在无参构造,有参构造方法(目的:为了分层初始化);