Java学习笔记（9）

final关键字;  (修饰符)

final关键字的用法：

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

public class FinalTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Circle c=new Circle(4.0);
        c.getArea();
        //c=new Circle();
    }

}
class Circle {
    double r;
    final double pi=3.14;
    public Circle() {}
    public Circle (double r) {
        this.r=r;
    }
    public void getArea() {
        System.out.println("圆的面积是： "+r*r*pi);
    }
}

调用方法时，传递的形式参数只是变量存储的值，没有把变量本身传过去。

不同方法 上面的局部变量是相互独立的，没有任何的关系。

比如：

public class FinalTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final Circle c=new Circle(4.0);
        test(c);
        //c=new Circle();
    }
    
    public static void test(Circle c) {
        c=new Circle();
        c.getArea();
    }
}

其中的test函数中的形式参数只是名字与上面的相同，其实没有关系，也可以将形式参数名称改为 Circle b，这样不会混淆。

public class FinalTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final Circle c=new Circle(4.0);
        test(c);
        //c=new Circle();
    }
    
    public static void test(Circle b) {
        b=new Circle(5.0);
        b.getArea();
    }
}

结果为      圆的面积是： 78.5    而不是  50.24

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

抽象类：

抽象类要注意的细节：

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

public class Abstract {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dog d=new Dog("哈士奇","白色");
        d.run();
        Fish f=new Fish("金鱼","红色");
        f.run();
    }

}
abstract class Animal {
    String name;
    String color;
    public Animal(String name,String color) {
        this.name=name;
        this.color=color;
    }
    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+"摇尾巴游得快");
    }
}

抽象类的应用场景：

• 我们在描述一类事物的时候，发现该种事物确实存在着某种行为，但是这种行为目前是不具体的，那么我们可以抽取这种行为的声明，但是不去实现该种行为，这时候这种行为我们称为抽象的行为，我们就需要使用抽象类

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

常量的命名规范：全部字母大写，单词与单词之间使用下划线分分隔。

public class AbstractTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Circle c=new Circle("圆形",4.0);
        c.getArea();
        c.getLength();
        
        Rect r=new Rect("矩形",3,4);
        r.getArea();
        r.getLength();
    }

}
abstract class MyShape{
    String name;
    public MyShape() {}
    public MyShape(String name) {
        this.name=name;
    }
    public abstract void getArea() ;
    public abstract void getLength();
}
//圆形
class Circle extends MyShape{
    double r;
    public static final double PI=3.14;
    public Circle(String name,double r) {
        super(name);
        this.r=r;
    }
    public void getArea() {
        System.out.println(name+"的面积是："+r*r*PI);
    }
    public void getLength() {
        System.out.println(name+"的周长是："+2*PI*r);
    }
}
//矩形
class Rect extends MyShape{
    int width;
    int height;
    public Rect(String name,int width,int height){
        super(name);
        this.width=width;
        this.height=height;
    }
    public void getArea() {
        System.out.println(name+"的面积是："+width*height);
    }
    public void getLength() {
        System.out.println(name+"的周长是："+2*(width+height));
    }
}

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

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

值交换：

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

重点：

1. 形式参数是数据所属函数的局部变量
2. 不同函数的局部变量与局部变量是相互独立，没有任何的关系。

如果是不同的引用类型变量操作同一个对象，那么肯定回影响到结果。

一个类最多只能由一个直接的父类。    Java是单继承的

接口：

接口的定义格式：

　　　　interface   接口名{

　　　　}

接口要注意的事项：

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

实现接口的格式：

　　　　class  类名  implements   接口名{

　　　　}

public class Interface {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        PencilWithEraser p=new PencilWithEraser("2B铅笔");
        p.write();
        p.remove();
    }

}
//普通的铅笔类
class Pencil{
    String name;
    public Pencil() {}
    public Pencil(String name) {
        this.name=name;
    }
    public void write() {
        System.out.println(name+"沙沙的写");
    }
}
//橡皮接口
interface Eraser{
    public void remove();
}
//带橡皮的铅笔
class PencilWithEraser extends Pencil implements Eraser{
    public PencilWithEraser(String name) {
        super(name);
    }
    public void remove() {
        System.out.println(name+"涂改");
    }
}

接口的作用：

1. 拓展功能
2. 定义约束规范
3. 程序的解耦（程序设计要设计成低耦合）     （从上往下越来越重要  这些功能）

例：

public class InterfaceTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student s=new Student("李四");
        s.study();
        MoneyStudent m=new MoneyStudent("张三");
        m.study();
        m.makeMoney();
    }

}
//普通的学生类
class Student{
    String name;
    public Student() {}
    public Student(String name) {
        this.name=name;
    }
    public void study() {
        System.out.println(name+"好好学习");
    }
}
//接口  会挣钱是学生的拓展功能---定义在接口上
interface Money{
    public void makeMoney();
}
//会挣钱的学生
class MoneyStudent extends Student implements Money{
    public MoneyStudent(String name) {
        super(name);
    }
    public void makeMoney() {
        System.out.println(name+"好好挣钱，然后交学费！");
    }
}

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

类与接口要注意的事项：

1. 非抽象类实现一个接口时，必须要把接口中的所有方法全部实现
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的方法
3. 一个类可以实现多个接口
   1. 　　思考：为什么Java不实现多继承，而实现多接口呢？

接口与接口的关系：继承关系

接口与接口之间的注意事项：

1. 一个接口是可以继承多个接口的

多态：一个对象具备多种形态（父类的引用类型变量指向了子类的对象或者是接口的引用类型变量指向了接口实现类的对象）   动物 a=new 狗（）；

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

多态要注意的细节：

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

总结：

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

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

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

多态的应用：

1.多态用于形式参数类型的时候，可以接受更多类型的数据

2.多态用于返回值类型的时候，可以返回更多类型的数据

public class Kinds {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Circle c=new Circle("圆形",4.0);
        print(c);
        Rect r=new Rect("矩形",3,4);
        print(r);
    }
    public static void print(MyShape s) { //MyShape s=new Circle();  多态
        s.getArea();
        s.getLength();
    }

}
abstract class MyShape{
    String name;
    public MyShape() {}
    public MyShape(String name) {
        this.name=name;
    }
    public abstract void getArea() ;
    public abstract void getLength();
}
//圆形
class Circle extends MyShape{
    double r;
    public static final double PI=3.14;
    public Circle(String name,double r) {
        super(name);
        this.r=r;
    }
    public void getArea() {
        System.out.println(name+"的面积是："+r*r*PI);
    }
    public void getLength() {
        System.out.println(name+"的周长是："+2*PI*r);
    }
}
//矩形
class Rect extends MyShape{
    int width;
    int height;
    public Rect(String name,int width,int height){
        super(name);
        this.width=width;
        this.height=height;
    }
    public void getArea() {
        System.out.println(name+"的面积是："+width*height);
    }
    public void getLength() {
        System.out.println(name+"的周长是："+2*(width+height));
    }
}

结果为：

圆形的面积是：50.24
圆形的周长是：25.12
矩形的面积是：12
矩形的周长是：14

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

应用二：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Circle c=new Circle("圆形",4.0);
        print(c);
        Rect r=new Rect("矩形",3,4);
        print(r);
        
        MyShape m=getShape(1); //注意不能使用Rect或者Circle类型来接受，因为函数返回值类型为MyShape不能确定到底返回的是哪种
        m.getArea();
        m.getLength();
        MyShape n=getShape(0); //调用了使用多态的方法，定义的变量类型
        n.getArea();
        n.getLength();
    }
    //定义一个函数接受任意类型的图形，然后计算任意图形的周长及面积
    public static void print(MyShape s) { //MyShape s=new Circle();  多态
        s.getArea();
        s.getLength();
    }
    //定义一个函数返回任意类型的图形
    public static MyShape getShape(int i) {
        if (i==0) {
            return new Circle("圆形",4.0);
        }
        else {
            return new Rect("矩形",3,4);
        }
    }

此时结果为：

矩形的面积是：12
矩形的周长是：14
圆形的面积是：50.24
圆形的周长是：25.12