final关键字 多态 抽象

final关键字：

        final的用法:

                final可以修类,该类不能继承
                fianl可以修饰成员方法,该方法不能被重写
                final可以变量(成员/局部变量),这个时候变量就变成了一个常量!(常用)

代码：

class Father{
public int num = 100;
public final int num2 = 200 ; 
public void method(){
int num = 20 ;
int num2 = 50 ;
System.out.println("show Father....");

}

final public void function(){
System.out.println("function Father...");
}
}
class Son extends Father{
public void show(){
System.out.println("show Son...");
}

//该方法在父类已经被final修饰
// public void function(){
//
// }
}
//测试类
public class FinalDemo {
public static void main(String[] args) {
Son s = new Son() ;
// s.num2 = 100;//此时num2不能在更改,已经常量
}
}

   关于final修饰变量(基本数据类型(引用类型))的问题:

       final修饰基本数据类型:基本数据类型的值不能在改变,变量此时是常量
       final修饰引用类型:引用类型的地址值不能发生改变,对象中堆内存的值是可以改变的(考点)

final初始化时机的问题:

   final去修饰变量,这个变量是常量,只能修改一次(常量)；在调用构造方法之前,被final修饰的变量去使用它

代码：

class Code{




int num ;
final int num2 ;


//num3 常量
//属于在构造方法之前去调用
{
num= 100 ;
num2= 30 ;
//System.out.println(num2);
}

public Code(){
//  num2 = 20 ;//
//  num3 = 200 ;
System.out.println(num);//num
System.out.println(num2) ;
}
}
//参数类
public class FinalTest {
public static void main(String[] args) {
Code c = new Code() ;

}

}

多态

        定义：

   指的是一个事物，在不同时刻状态的一个体现。
水:固态,气态,液态;
  Dog d = new Dog();//创建了一个狗类的对象
  Animal a = new Dog();狗是一个动物
  = new cat();
  

        多态的前提条件:

  1)必须有继承关系
  2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)
  动物类:吃和睡的功能,子类重写父类的方法的原因:使用子类中有具体的功能..
  
  3)父类的引用指向子类对象
  继承的时候:使用子类的:Zi z = new Zi() ;
  Fu f = new Zi();将f代表的父类引用指向堆内存的子类的对象!
  向上转型!
 

     多态中的成员访问特点:

  成员变量:

  编译看左,运行看左!

  非静态成员方法:

  编译看左,运行看右
  子类中的方法会覆盖掉父类中的方法

  静态的成员方法:

  编译看左边,运行看左边
  (静态和类有关系)
  构造方法:始终是给对象进行初始化的!..
  

        多态的弊端:

                       子类只能使用父类的功能:不能使用子类中特有的功能!

  要想使用子类具体功能

     1.创建子类对象
     2.向下转型:将父类的引用强制转换为子类对象
  Zi z = (Zi)(f) ;//还原成子类对象
向下转型会出现一个异常：
class Animal2{
public void eat(){
}
public void sleep(){}
}


class Cat2 extends Animal2{

}
class Dog2 extends Animal2{

}
public class DuoTaiDemo4 {
public static void main(String[] args) {
//使用向上转型
Animal2 a = new Cat2() ;//猫是动物:内存是猫

//还原成猫
//向下转型
Cat2 c1 = (Cat2) a ;//内存还是猫

//向上转型:
a = new Dog2() ;//内存是狗
//还原成狗
Dog2 d = (Dog2) a ;//内存还是狗

Cat2 c2 = (Cat2) a ;//编译不报错!,运行发生一个异常!:ClassCastException:(RuntimeException:运行时期的异常!)

// Dog2 dd = (Dog2) a;
}
}

多态的好处:

     提高了代码的维护性(由继承保证)
     提高了代码的扩展性(由多态的保证)

抽象：

                概述：

                将功能定义抽象,那么该类就是抽象类!

                java针对将一个类定义为抽象----------->abstract:抽象的意思

抽象类的特点:

  一个类中可以抽象方法.也可以有非抽象方法

  抽象方法的格式:

  public abstract void method();

  抽象类的子类特点:

  子类可以是抽象类,没有任何意义!抽象类不能直接实例化,就不能使用调用调用方法!
  子类是非抽象类,必须要重写父类中的抽象方法,然后去使用子类的自己的功能
  父类是一个抽象类,如果要创建对象就必须通过子类进行实现!
  父类进行实例化只能间接子类进行实例化!

代码：

//非抽象类
abstract class Animal{
public void show(){} //非抽象方法

// public  abstract void method(){} //有语句体的

//抽象方法
public abstract void eat();//空语句体!
public abstract void sleep();
}


//abstract class Cat extends Animal{
// public void eat(){
// System.out.println("猫吃鱼...");
// }
//}
class Cat extends Animal{


@Override
public void eat() {
System.out.println("猫吃鱼...");
}


@Override
public void sleep() {
// TODO Auto-generated method stub

}

}


class Dog extends Animal{


@Override
public void eat() {
System.out.println("狗吃骨头...");
}


@Override
public void sleep() {
// TODO Auto-generated method stub

}

}


//测试类:
public class AbstractDemo {
public static void main(String[] args) {
//创建动物类对象
// Animal a = new Animal();//抽象类不能直接实例化(创建对象)
//使用子类具体的功能,就需要创建子类对象
// Cat c = new Cat();

Animal a = new Cat() ;//属于多态的第三个条件
a.eat();
}
}

抽象类中的成员的特点:

  成员变量:可以是变量,也可以是常量!(自定义常量)
  成员方法:可以是抽象方法,也可以是非抽象方法
  构造方法:一个抽象类中是可以有构造方法的! 
                  抽象类这个抽象方法是强制要求子类必须实现的方法

   代码：

abstract class Fu{
//定义变量
public int num = 10 ;

//定义一个常量
final public int num2 = 20 ; 
    // num2 = 30;
 
public Fu(){}
 
//非抽象方法
public void show(){
System.out.println("show Fu");
}
 
//抽象方法
public abstract void method();
}


class Zi extends Fu{


@Override
public void method() {
System.out.println("method Zi");
}

}


//测试
public class AbstractDemo2 {
public static void main(String[] args) {
//创建对象
Fu f = new Zi();
System.out.println(f.num);
System.out.println(f.num2);
f.show();
f.method();
}
}

abstract不能和以下的关键字共用!

            关键字:private,final,static

抽象的成员方法修饰:

            public (使用的比较多)