复习，final关键字,抽象类，抽象类的练习以及不能与指定关键字一起使用

本文主要是介绍复习，final关键字,抽象类，抽象类的练习以及不能与指定关键字一起使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

static（静态、修饰符）

static修饰成员变量: 如果一个成员变量使用static修饰，那么该成员变量的数据就是一个共享 的数据.,、

静态成员变量的访问方式

方式一：可以使用对象访问。
对象.属性名
方式二：可以使用类名访问。
类名.属性名

注意：
1. 非静态成员变量不能使用类名直接访问，要使用对象访问.
2. 千万不要为了访问方便而使用static修饰。一定要数据真正是需要被共享的时候才使用static修饰。

static修饰成员函数:

静态函数的访问方式
方式一：可以使用对象访问。
对象.属性名
方式二：可以使用类名访问。
类名.属性名

推荐使用类名访问静态的成员。

静态函数要注意的细节：
1. 非静态函数只能由对象调用，静态函数可以由类名或者对象进行调用。
2. 静态函数中不能直接访问非静态成员，可以直接访问静态的成员。
3. 非静态函数可以直接访问非静态成员以及可以直接访问静态的成员。
4. 静态函数中不能出现this或者super关键字。

单例设计模式：保证一个类在内存中只有一个对象。

饿汉单例设计模式：
1. 私有化构造函数。
2. 声明本类的引用类型变量并且指向本类的对象，(private static)
3. 提供一个公共静态的方法获取本类对象。

懒汉单例设计模式:
1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象。
3. 提供一个公共静态的方法获取本类对象，获取之前先判断是否已经创建了本类的对象，
如果没有创建，创建再返回。如果已经创建了，那么直接访问即可。

继承：

继承的格式:

class 类名1 extends 类名2{

}

继承要注意的事项：
1. 父类私有的成员不能被继承。
2. 父类的构造函数不能被继承。
3. 创建子类对象时，默认会先调用父类的无参构造函数，然后再调用子类 的构造函数。

super关键字：super关键字代表的是父类的引用空间。

super关键字的作用：
1. 如果子父类存在同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问 父类的成员。
2. 创建子类对象时，默认会先调用父类的无参构造函数，可以通过super关键字指定调用父类的构造函数，

super关键字要注意的事项：
1. 如果在子类 的构造函数中没有指定调用具体父类构造函数，那么java编译器会在子类的构造函数上添加super()语句。
2. super关键字调用构造函数时必须出现构造函数中第一个语句。
3. this与super调用构造函数的时候不能同时出现在一个构造函数中，因为都需要是第一个语句。

方法重写：子父类存在着同名的函数。

方法重写的需求： 如果父类的功能无法满足子类的需求，那么就进行重写。

方法重写的要素：
1. 函数名与形参列表必须一致。
2. 子类的权限修饰符必须大于或者等于父类 的权限 修饰符。
3. 子父类的返回值类型必须小于或者等于父类的返回值类型。
4. 子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。

instanceof：判断一个对象是否属于某种类型。

instanceof关键字的使用格式：

对象 instanceof 类。

instanceof的使用前提：判断的对象与类型必须存在继承或者实现的关系。

final(最终、修饰符)

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 Demo27 extends Circle
{

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

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



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

}
运行结果：

抽象类：

目前存在的问题：
1. 动物类的run方法描述的不正确。
2. 没有强制要子类一定要重写run方法。

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

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

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

代码演示：

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

    String name;

    String  color;

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


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

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



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

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

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


//鱼 是属于动物中一种
class fish extends Animal2{


    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();
   */


    }
}
结果：

需求： 描述一个图形、圆形、 矩形三个类。不管哪种图形都会具备计算面积
与周长的行为，但是每种图形计算的方式不一致而已。

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

abstract不能与以下关键字共同修饰一个方法：
1. abstract不能与private共同修饰一个方法。
2. abstract 不能与static共同修饰一个方法。
3. abstract 不能与final共同修饰一个方法。

代码演示：

//abstract 抽象

//图形类
abstract class MyShape{

    String name;

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

    public  abstract void getArea();

    public abstract void getLength();
}

//圆形 是属于图形类的一种
class Circle1 extends MyShape{

    double r;

    public static final double PI = 3.14;

    public Circle1(String name,double r){
        super(name);
        this.r =r;
    }

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

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

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+"的面积是："+PI*r*r);
        }
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));
    }
}

class Demo4
{
    public static void main(String[] args)
    {
        //System.out.println("Hello World!");

        Circle c = new Circle("圆形",4.0);
        c.getArea();
        c.getLength();

        //矩形
        Rect r = new Rect("矩形",3,4);
        r.getArea();
        r.getLength();

    }
}
结果：

这篇关于复习，final关键字,抽象类，抽象类的练习以及不能与指定关键字一起使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！