有关继承,多态.排序算法之选择排序的文章

排序算法之选择排序

选择排序:
        使用0索引的元素依次和后面索引的元素比较,小的往前放
        第一次比较完毕,最小值出现在最小索引处!

50                 62                   49                    38                  81

0                   1                      2                        3                     4

 

public class ArrayDemo1 {
public static void main(String[] args) {
	//定义一个数组
	int[]arr= {50,62,49,38,81};
	printArray(arr);
	switchSort(arr);
}
//选择排序
public static void switchSort(int[]arr) {
	for(int x=0;x<arr.length-1;x++) {//比较次数
		for(int y=x+1;y<arr.length;y++) {
			if(arr[y] <arr[x]) {
				int teep=arr [x];
				arr[x]=arr[y];
				arr[y]=teep;
			}
		}
	}
}

//遍历
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]+", ");
		}
	}
		
	
}
}


      继承

概念:需要定义独立的类,将其他类的共性内容抽取到该独立的类中,让其他类和这个独立类的产生一种关系: "继承"关系.

继承的好处:
 *  1)提供了代码的复用性 (代码结构清晰)
 *  2)提供了了代码的维护性
 *  3)类和类产生的这种"继承关系",是多态的前提条件
 *  开发的原则:
 *      低耦合,高内聚

 继承的特点:
 * 
 *     1)在Java语言中,类和类之间只支持单继承,不支持多继承
 *       
 *     2)虽然不支持多继承,但是类与类之间是可以多层继承的!

子类继承父类,如果子类中的成员变量名称和父类的成员变量名称一致的情况:
 *
 *        执行流程:
 *            1)现在子类的局部位置中找,如果找到了就使用它
 *            2)如果局部位置中没有,在子类的成员位置中找,如果找到了,就使用!
 *            3)如果找不到,就在父类的成员位置中找,如果找到了,就使用
 *            4)如果还找不到,就报错了,说明访问了一个不存在的变量!
 *
 *    遵循:"就近原则"

 

继承中为什么,创建子类对象的时候,先执行父类的无参构造方法?
 *        答: 因为可能要用到父类中的数据,所以要先让父类中的数据进行初始化(构造方法),
 * 父类初始化完毕了,然后才执行子类的构造方法(子类数据初始化)---->分层初始化!

 

如果父类的无参构造方法没有提供,那么子类构造会出现什么情况?
 *     子类的所有构造方法默认父类的无参构造方法,父类如果没有提供,就报错了!
 * 
 *     如何解决呢?
 *         1)手动给出父类的无参构造方法 (之前说在写一个标准类的时候,建议永远给出无参构造方法)
 *        2)如果手动不提供无参构造方法,如何解决?    
 *            2.1)间接的通过super(xx)来访问父类的有参构造初始化!
 *            2.2)通过this(),访问本类(子类)的无参构造方法,然后在通过子类的无参构造方法里面super(xx)
 *                    间接访问父类的有参;
 * 

多态

概念:一个事物在不同时刻的体现.如水在不同时刻下显示出不同状态(固液气).

多态的成员访问特点:
 *  Fu  f = new Zi() ;
 *  成员变量:
 *          编译看左边,运行看左!
 *  (等号左边编译通过,说明Fu类存在这个变量;运行看左,访问的是Fu类的变量)
 *  成员方法:(与成员变量,静态成员方法有区别)
 *          编译看左边,运行看!
 *  (等号左边编译通过,说明Fu类存在这个方法;运行看右,子类出现了和父类一模一样的方法声明:方法重写)
 *  静态的成员方法:    
 *          编译看左,运行看左!(静态的算不上方法重写,跟类直接相关,随着类的加载而加载!)
 *  
 *  构造方法:存在继承关系(还是分层初始化)
 *              先让父类初始化,然后在是子类初始化!

多态的好处:
 *     1)提高了代码的复用性(由继承来保证)
 *  2)提高了代码的扩展性(由多态的来保证)

多态的弊端
 * 
 *         不能访问子类的特有功能!

解决方案:方案1):创建子类的具体对象来访问子类的特有功能!

方案2):

向下转型:    将父类的引用强转为子类的引用!  (前提必须有向上转型Fu  f = new Zi() )
 *        格式:
 *                Zi   z = (Zi)f;

 方法重写(override) :
 * 
 *     在继承关系中,子类出现了和父类一模一样的方法,这时子类会将父类的该功能覆盖掉,将这种现象
 *称为:方法重写.

为了让父类的功能不被子类覆盖:引出final关键字.

final:最终的,无法更改的(状态修饰符)
 *  被final修饰的成员方法:该方法不能被子类重写!

抽象类

概念:在一个类中,如果该类中存在一个功能,仅仅方法声明,没有方法体(抽象方法),需要将该类定义抽象类.

抽象类的成员特点:
 *     1)成员变量
 *             即可定义一个常量,也可以定义为变量
 *  2)成员方法:
 *      既可以定义抽象方法,也可以定义非抽象方法    
 *  3)构造方法:    
 *          存在构造方法,既可以有参构造也可以是无参构造方法(作用:对数据进行初始化)
 *  
 定义成员方法的时,abstract关键字不能和哪些关键字共用 ?
 *     和final关键字冲突
 *     和private关键字冲突
 *     和static关键字冲突
 * 
 * 能够和public或者protected权限修饰符使用!

接口

接口(interface):体现的是事物的一种扩展性功能.(本身不具备的).

接口不能实例化,如何实例化呢?
 *             通过接口的子实现类来进行实例化!
 *             格式:接口名  对象名  =new 子实现类名(); 

Love love=new Loveimpl();

  
 *             接口和子实现类之间的关系:实现关系(implements)

接口 成员特点:
 *         成员方法:
 *             只能是抽象方法,存在默认的修饰符,public abstract
 *         成员变量:
 *             只能是常量.存在默认的修饰符:public static final
 * 
 *         构造方法: 
 *             不存在构造方法!

内部类

内部类的分类:
 *         成员内部类
 *                 在外部类的成员位置定义的类
 *         局部内部类
 *                 在局部位置(外部类的成员方法中)定义的一个类
 * 访问内部类的成员:
 *访问方式:
 *
 *        外部类名.内部类名 对象名 = 外部类对象().内部类对象();
 * 

匿名内部类:

格式:

new 类名/接口名(){

    重写方法();
};

匿名内部类   好处:

省去繁杂代码,不需要定义类里面的子类或者接口的子实现类,写法比较简单.

匿名内部类    本质:

继承该类或者实现了该接口的子类对象.

JDK7以前(包含JDK7),局部内部类访问局部变量,局部变量必须加入final修饰,否则报错!
 * JDK7以后,局部变量会自动加上final,开发者不需要定义final关键字,为什么要加final?

 *             
 *         原因:
 *             1)局部变量的生命周期,随着方法调用而存在,随着方法调用完毕而消失,
 *2)在当前外部类成员方法中,创建局部内部类对象,来访问里面的局部变量,堆内存不会立即被释放
 

//定义外部类

class Outer{

    private   int num=30;

//成员方法

    public void method (){

//局部变量

    final int num2=70;

//局部内部类

class Inter{

    public void show(){

                    }

            }

        }

    }


 *3)继续使用这个局部变量,需要将这个变量定义为常量,常驻内存---->以便局部内部类对象对该局部变量的访问!

 

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页