Java_Day06学习

抽象类

1.定义：Java也可以创建一种类专门用来当作父类，这种类称为“抽象类”；
//抽象类的作用有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。
    eg:
	abstract class 类名称 // 定义抽象类
{
    声明数据成员;
    
    访问权限 返回值的数据类型 方法名称（参数...）//定义一般方法
    {
        ...
    }
    
    abstract 返回值的数据类型 方法名称（参数...）;
    //定义抽象方法，在抽象方法里，没有定义方法体
}
//但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例
//普通类可以被实例化

2.规则：
    //抽象类和抽象方法都必须用abstract关键字来修饰；
    //抽象类不能被实例化，也就是不能用new关键字去产生对象；
    //抽象方法只需声明，而不需实现；
    //含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才		能被实例化，否则这个子类还是个抽象类。


2.抽象方法VS普通方法
有无方法体
    
    
    
3.抽象类与抽象方法的使用
    //抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
    //如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
    //没有抽象构造方法，也没有抽象静态方法
    //抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
    
4.eg：
    public class abstractTest {
	public static void main(String[] args) {
		/********* begin *********/
		// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
        Student stu = new Student();
        stu.talk("张三",20,"学生");
		Worker work = new Worker();
        work.talk("李四",30,"工人");
		// 分别调用各自类中被复写的talk()方法 打印信息。
		
		/********* end *********/
		
	}
}

// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
	/********* begin *********/
    String name;
    int age;
    String occupation;
    abstract void talk(String name,int age,String occupation);
	/********* end *********/
}

// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
	/********* begin *********/
    public void Student(String name,int age,String occupation){
        this.name = name;
        this.age = age;
        this.occupation = occupation;
    }
    public void talk(String name,int age,String occupation){
        System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }
	/********* end *********/
}

// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
	/********* begin *********/
    public void Worker(String name,int age,String occupation){
        this.name = name;
        this.age = age;
        this.occupation = occupation;
    }
    public void talk(String name,int age,String occupation){
        System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }
	/********* end *********/

}
    
    

final

1. final 使用规则：
    final 标记的类不能被继承；
    final 标记的方法不能被子类复写；
    final 标记的变量（成员变量或局部变量）即为常量，只能赋值一次
    
2. final 修饰类：
    //final用来修饰一个类，意味着该类成为不能被继承的最终类。
    //出于安全性的原因和效率上的考虑，有时候需要防止一个类被继承，保证了String类的惟一性
    //如果你认为一个类的定义己经很完美，不需要再生成它的子类，这时也应把它修饰为final类。
    //声明为final的类隐含地声明了该类的所有方法为final方法
3. final 修饰成员变量
    变量被声明为final后，成为常值变量(即常量)一旦被通过某种方式初始化或赋值，即不能再被修改。
    通常 static与final一起 使用来指定一个类常量。
    //把final变量用大写字母和下划线来表示，这是一种编码规定
    static final int  MAX_SIZE = 10;
4. final 修饰成员方法
	//用final修饰的方法为最终方法，不能再被子类重写，可以被重载。
    //尽管方法重写是Java非常有力的特征，但有时却需要避免这种情况的发生。
    //为了不允许一个方法被重写，在方法的声明中指定final属性即可。
    class A{final void method(){} }
	class B extends A{//定义A类的一个子类B
        void method(){}//错误，method()不能被重写
		}
	方法被声明为final有时可以提高性能：编译器可以自由地内联调用它们，因为它“知道”它们不会被子类重写。
    
        
        
eg:


public class finalTest {
	public static void main(String args[]) {
		Bike1 obj = new Bike1();
		obj.run();
        
		Honda honda = new Honda();
		honda.run();

		Yamaha yamaha = new Yamaha();
                yamaha.run();
	}
}
    //不可以修改 final 变量的值
    // final方法,不可以重写
     不可以扩展 final 类
    //请在此添加你的代码
class Bike1 {
	int speedlimit = 90;
	void run() {
		speedlimit = 120; 
		System.out.println("speedlimit=120");
	}
}

class Bike2 {
	void run() {
		System.out.println("running");
	}
}

class Honda extends Bike2 {
	final void run() { 
		System.out.println("running safely with 100kmph");
	}
}

class Bike3 {
}

class Yamaha extends Bike3 { 
	void run() {
		System.out.println("running safely with 100kmph");
	}
}
    

接口

public interfaceMyInterface {public void foo()；//其他方法}
java中把经常用到的方法放到父类中 ，而接口主要是扩展类能力的一种方法
    父类中继承下来的一般都是对数据库增删改查高度调用的方法
1.接口的特性
	//接口不可以被实例化
	//实现类必须实现接口的所有方法
    //实现类可以实现多个接口 implements、多个接口使用逗号隔开
    //接口中的变量都是静态常量（public static final）
2.面向接口编程
    程序设计时：
    	关心实现类有何能力，而不关心实现细节
    	面向接口的约定而不考虑接口的具体实现