java基础--抽象类、接口

final(最终、修饰符) ##

final关键字的用法：

1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
3. final关键字修饰一个函数的时候，该函数不能被重写。
4. final关键字修饰一个类的时候，该类不能被继承。

常量 的修饰符一般为： public static final

//圆形
class Circle{

double r; //半径

public static final double pi = 3.14; //固定不变的

public Circle(double r){
    this.r = r;
}

//计算面积
public final void getArea(){
    System.out.println("圆形的面积是："+r*r*pi);
}
}



class Demo2 extends Circle
{

public Demo2(double r){
    super(r);
}

public static void main(String[] args) 
{
    /*
    final Circle c = new Circle(4.0);
    test(c);//不会报错
    */  
    Demo2 c = new Demo2(4.0);
    c.getArea();
}



public static void test(Circle c){
    c = new Circle(5.0);  //c变量又重新指向了新的对象。
    c.getArea();
}

抽象类

抽象类的应用场景：

我们在描述一类事物的时候，发现该种事物确实存在着某种行为，

但是这种行为目前是不具体的，那么我们可以抽取这种行为 的声明，但是
不去实现该种行为，这时候这种行为我们称作为抽象的行为，我们就需要使用抽象类。

抽象类的好处: 强制要求子类一定要实现指定的方法。

抽象类要注意的细节：

1. 如果一个函数没有方法体，那么该函数必须要使用abstract修饰,把该函数修饰成抽象 的函数。。
2. 如果一个类出现了抽象的函数，那么该类也必须 使用abstract修饰。
3. 如果一个非抽象类继承了抽象类，那么必须要把抽象类的所有抽象方法全部实现。
4. 抽象类可以存在非抽象方法，也可以存在抽象的方法.
5. 抽象类可以不存在抽象方法的。 
5. 抽象类是不能创建对象的。
    疑问：为什么抽象类不能创建对象呢？
    因为抽象类是存在抽象方法的，如果能让抽象类创建对象的话，那么使用抽象的对象
    调用抽象方法是没有任何意义的。
6. 抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。

//动物类--->抽象类
abstract class Animal{

String name;

String  color;

public Animal(String  name,String color){
    this.name = name;
    this.color = color;
}


//非抽象的方法
public void eat(){
    System.out.println(name+"吃粮食");
}

//移动...
public abstract void run();
}



//狗 是属于动物中一种 
class Dog extends Animal{

public Dog(String name,String color){
    super(name,color);
}

public void run(){
    System.out.println(name+"四条腿跑得很快...");
}
}


//鱼 是属于动物中一种
class Fish extends Animal{


public Fish(String name,String color){
    super(name,color);
}


public void run(){
    System.out.println(name+"摇摇尾巴游啊游！");
}
}


class Demo3 {

public static void main(String[] args) 
{
    /*
    Dog d = new Dog("牧羊犬","棕色");
    d.run();

    //创建一个鱼对象
    Fish f  = new Fish("锦鲤","金黄色");
    f.run();
    */

    Animal a = new Animal();

}
}

abstract不能与以下关键字共同修饰一个方法：

1. abstract不能与private共同修饰一个方法。
2. abstract 不能与static共同修饰一个方法。
3. abstract 不能与final共同修饰一个方法。

值传递

值传递: 调用一个方法的时候，传递给方法的参数 ，实际上传递变量所存储的值。

一个类最多只能有一个直接的父类。但是有多个间接的父类。

java是单继承。

接口

接口的定义格式：

interface 接口名{

}

接口要注意的事项 ：

1. 接口是一个特殊的类。
2. 接口的成员变量默认的修饰符为： public static final 。那么也就是说接口中的成员变量都是常量。
3. 接口中 的方法都是抽象的方法，默认的修饰符为： public abstract。
4. 接口不能创建对象。
5. 接口是没有构造方法的。
6. 接口是给类去实现使用的，非抽象类实现一个接口的时候，必须要把接口中所有方法全部实现。

实现接口的格式：

class  类名 implements 接口名{

}

interface A{

//成员变量
public static final int i=10;

//成员函数
public void print();
}


class Demo7 implements A{ // Demo7就实现了A接口

//实现接口中的方法
public void print(){
    System.out.println("这个是接口中的print方法...");
}   
}


public static void main(String[] args) 
{
    Demo7 d = new Demo7();
    d.print();
}

接口的作用：

1. 程序的解耦。  （低耦合）
2. 定义约束规范。
3. 拓展功能。

类、接口之间的关系

类与接口之间关系： 实现关系。

类与接口要注意的事项：

1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的方法。
3. 一个类可以实现多个接口 。

    疑问： java为什么不支持多继承，而支持了多实现呢？
        class A{

            public void print(){
                System.out.println("AAAAAA");
            }
        }

        class B{

            public void print(){
                System.out.println("BBBBBB");
            }
        }


        class C extends A ,B{

        }

        new C().print();

接口与接口之间关系： 继承关系。

接口与接口之间要注意事项：
1. 一个接口是可以继承多个接口的。非抽象类实现这个接口的时候，还要实现其父接口的方法

多态

面向对象的三大特征：
1. 封装
2. 继承。
3. 多态

多态：一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)

或者是接口 的引用类型变量指向了接口实现类的对象)

多态的前提：必须存在继承或者实现 关系。

动物  a  = new   狗();

多态要注意 的细节：

1.  多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
2.  多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3.  多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。

4.  多态情况下，不能访问子类特有的成员。

总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。

编译看左边，运行不一定看右边。

编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。

//动物类
abstract class Animal{

String name;

String  color = "动物色";

public Animal(String name){
    this.name = name;
}

public abstract void run();

public static void eat(){
    System.out.println("动物在吃..");
}

}

//老鼠
class  Mouse extends Animal{

String color = "黑色";

public Mouse(String name){
    super(name);
}

public  void run(){
    System.out.println(name+"四条腿慢慢的走!");
}

public static void eat(){
    System.out.println("老鼠在偷吃..");
}

//老鼠特有方法---打洞
public void dig(){
    System.out.println("老鼠在打洞..");
}
}



class Fish extends Animal {

public Fish(String name){
    super(name);
}


public  void run(){
    System.out.println(name+"摇摇尾巴游..");
}
}


class Demo11 
{
public static void main(String[] args) 
{
    /*
    Mouse m = new Mouse("老鼠");
    System.out.println(m.color);

    //多态： 父类的引用类型变量指向子类的对象
    */
    Animal a = new Mouse("老鼠");
    a.dig();
    //a.eat();
}   
}

多态的应用：

1. 多态用于形参类型的时候，可以接收更多类型的数据 。
2. 多态用于返回值类型的时候，可以返回更多类型的数据。

多态的好处： 提高了代码的拓展性。

需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。

//图形类
abstract class MyShape{

public abstract void getArea();

public abstract void getLength();   
}



class Circle extends MyShape{

public static final double PI = 3.14;

double r;

public Circle(double r){
    this.r =r ; 
}

public  void getArea(){
    System.out.println("圆形的面积："+ PI*r*r);
}

public  void getLength(){
    System.out.println("圆形的周长："+ 2*PI*r);
}
}


class Rect  extends MyShape{

int width;

int height;

public Rect(int width , int height){
    this.width = width;
    this.height = height;
}

public  void getArea(){
    System.out.println("矩形的面积："+ width*height);
}

public  void getLength(){
    System.out.println("矩形的周长："+ 2*(width+height));
}
}



class Demo12 {

public static void main(String[] args) 
{
    /*
    //System.out.println("Hello World!");
    Circle c = new Circle(4.0);
    print(c);

    Rect r = new Rect(3,4);
    print(r);
    */

    MyShape m = getShape(0); //调用了使用多态的方法，定义的变量类型要与返回值类型一致。
    m.getArea();
    m.getLength();


}


//需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
public static void print(MyShape s){ // MyShpe s = new Circle(4.0);
    s.getArea();
    s.getLength();
}


// 需求2： 定义一个函数可以返回任意类型的图形对象。
public static MyShape  getShape(int i){
    if (i==0){
        return new Circle(4.0);
    }else{
        return new Rect(3,4);
    }
}

}