Java中final关键字,抽象类与接口

最新推荐文章于 2023-07-31 17:23:07 发布
最新推荐文章于 2023-07-31 17:23:07 发布
阅读量2k 收藏 1
点赞数
分类专栏： 1. Java 文章标签： java 编程 string fun interface class

转载：http://yhalg1314.iteye.com/blog/742887

抽象类与接口是Java中最重要部分之一,这里用较大的篇幅来做下这部分的笔记.

1. final关键字

      在Java中, 可以使用final关键字修饰类、方法以及成员变量。

      (1).final标记的类不能被继承;

      (2).final标记的方法不能被子类复写;

      (3).final标记的变量即成为常量,只能被赋值一次.

      注意: 如果使用final来声明常量,请遵守以下常规: final标记的变量名,所有单词字母都需大写.

2. 抽象类

      讲抽象类的定义必须先讲抽象方法的定义. 所谓抽象方法,是指只声明而未实现(即没有{}包围的方法体)的方法. 而含有一个或多个抽象方法的类就称为抽象类.

      抽象类 = 普通类 + 抽象方法

      对于抽象类,时刻需要谨记: 抽象类是不能够直接实例化的, 如果要使用一个抽象类,就必须要有该抽象类的子类. 如果抽象类的子类不是抽象类的话,就一定要复写该抽象类的所有抽象方法.

      如下面代码示例:      

abstract class Person   
{   
    //全局常量的命名一定要采取全部字母大写的方式   
    public static final String NAME = "newsainton";   
    //print()方法有方法体,所以不是抽象方法   
    public void print()   
    {   
        System.out.println("非抽象方法中,Name = "+NAME);   
    }   
    //fun()方法不含方法体,为抽象方法   
    public abstract void fun();   
}   
//B类继承自A类,但B未声明为抽象类,则必须要复写A类中所有的抽象方法   
class Student extends Person   
{   
    public void fun()   
    {   
        System.out.println("抽象方法中,Name = "+super.NAME);   
    }   
}   
public class Demo01   
{   
    public static void main(String args[])   
    {   
        Student s = new Student();   
        s.fun();   
        s.print();   
    }   
} 
abstract class Person 
{ 
//全局常量的命名一定要采取全部字母大写的方式 
public static final String NAME = "newsainton"; 
//print()方法有方法体,所以不是抽象方法 
public void print() 
{ 
   System.out.println("非抽象方法中,Name = "+NAME); 
} 
//fun()方法不含方法体,为抽象方法 
public abstract void fun(); 
} 
//B类继承自A类,但B未声明为抽象类,则必须要复写A类中所有的抽象方法 
class Student extends Person 
{ 
public void fun() 
{ 
   System.out.println("抽象方法中,Name = "+super.NAME); 
} 
} 
public class Demo01 
{ 
public static void main(String args[]) 
{ 
   Student s = new Student(); 
   s.fun(); 
   s.print(); 
} 
}

?

      另外一个需要考虑的问题是: 抽象类可否有自己的构造方法?

      答案是: 抽象类中允许有自己的构造方法,但是该构造方法并不能直接实例化自己的对象. 如果在抽象类中存在有参构造方法,则必须在子类中明确的使用super([参数列表])指明要调用父类中的哪个构造方法.

      这里举例如下:   

abstract class Person   
{   
    // 应该有姓名和年龄属性   
    private String name ;   
    private int age ;   
    public Person(){}   
    // 如果已经不是无参的，则必须在子类中明确调用无参构造   
    public Person(String name,int age)   
    {   
        this.name = name ;   
        this.age = age ;   
    }   
    public String getName()   
    {   
        return this.name ;   
    }   
    public int getAge()   
    {      
        return this.age ;   
    }   
    // 定义一个输出方法，但是此方法为抽象方法   
    public abstract String getInfo() ;   
}   
class Student extends Person   
{   
    public Student(String name,int age)   
    {   
        // 调用Person类中有两个参数的构造方法   
        super(name,age) ;   
    }   
    public String getInfo()   
    {   
        return "姓名 = "+super.getName()+"，年龄 = "+super.getAge() ;   
    }   
}   
public class Demo05   
{   
    public static void main(String args[])   
    {   
        Student s = new Student("张三",30) ;   
        System.out.println(s.getInfo()) ;   
    }   
} 
abstract class Person 
{ 
// 应该有姓名和年龄属性 
private String name ; 
private int age ; 
public Person(){} 
// 如果已经不是无参的，则必须在子类中明确调用无参构造 
public Person(String name,int age) 
{ 
   this.name = name ; 
   this.age = age ; 
} 
public String getName() 
{ 
   return this.name ; 
} 
public int getAge() 
{ 
   return this.age ; 
} 
// 定义一个输出方法，但是此方法为抽象方法 
public abstract String getInfo() ; 
} 
class Student extends Person 
{ 
public Student(String name,int age) 
{ 
   // 调用Person类中有两个参数的构造方法 
   super(name,age) ; 
} 
public String getInfo() 
{ 
   return "姓名 = "+super.getName()+"，年龄 = "+super.getAge() ; 
} 
} 
public class Demo05 
{ 
public static void main(String args[]) 
{ 
   Student s = new Student("张三",30) ; 
   System.out.println(s.getInfo()) ; 
} 
}

   

?

 3. 接口(interface)

     3.1 接口的概念

         接口是抽象方法与常量的结合.

        接口的定义方式为: interface 接口名 { 数据类型 常量名 = 常量值; 返回值类型 方法名(); .......}

        在Java中,一个类只能继承一个类,但是却可以实现(implements)多个接口. 如果实现接口的类不是抽象类的话,则该子类必须复写接口中所有的抽象方法.

      例如如下代码示例:   

interface Person   
{   
    //接口中包含了抽象类和抽象方法   
    public static final String NAME = "newsainton";   
    public abstract void fun();   
}   
// 一个类可以继承多个接口,但如果该类不是抽象类的话,则必须实现抽象类中的所有抽象方法   
class Student implements Person   
{   
    public void fun()   
    {   
        System.out.println("name = "+NAME);   
    }   
}   
public class Demo02   
{   
    public static void main(String args[])   
    {   
        Student s = new Student();   
        s.fun();   
    }   
} 
interface Person 
{ 
//接口中包含了抽象类和抽象方法 
public static final String NAME = "newsainton"; 
public abstract void fun(); 
} 
// 一个类可以继承多个接口,但如果该类不是抽象类的话,则必须实现抽象类中的所有抽象方法 
class Student implements Person 
{ 
public void fun() 
{ 
   System.out.println("name = "+NAME); 
} 
} 
public class Demo02 
{ 
public static void main(String args[]) 
{ 
   Student s = new Student(); 
   s.fun(); 
} 
}

   

?

   3.2 接口的两点注意之处

        (1). 抽象类使的是extends关键字，表示一个类只能继承一个父类，但是接口使用的是implements，一个类可以同时实现多个接口，但是此时子类就必须同时覆写好多个接口中的抽象方法。

        (2). 既然定义中已经明确说明了接口是抽象方法和全局变量的集合,因此,我们可以如下例一样,对代码进行简化:    

interface Person   
{   
    //接口中包含了抽象类和抽象方法   
    //public static final String NAME = "newsainton";   
    public String NAME = "newsainton";   
    //public abstract void fun();   
    public void fun();   
}   
// 一个类可以继承多个接口,但如果该类不是抽象类的话,则必须实现抽象类中的所有抽象方法   
class Student implements Person   
{   
    public void fun()   
    {   
        System.out.println("name = "+NAME);   
    }   
}   
public class Demo03   
{   
    public static void main(String args[])   
    {   
        Student s = new Student();   
        s.fun();   
    }   
} 
interface Person 
{ 
//接口中包含了抽象类和抽象方法 
//public static final String NAME = "newsainton"; 
public String NAME = "newsainton"; 
//public abstract void fun(); 
public void fun(); 
} 
// 一个类可以继承多个接口,但如果该类不是抽象类的话,则必须实现抽象类中的所有抽象方法 
class Student implements Person 
{ 
public void fun() 
{ 
   System.out.println("name = "+NAME); 
} 
} 
public class Demo03 
{ 
public static void main(String args[]) 
{ 
   Student s = new Student(); 
   s.fun(); 
} 
}

  

?

   3.3 接口与接口之间的关系

      一个接口可以使用extends关键字去继承一个或多个已有的接口,但在子类的实现时,也必须全部实现所有接口的抽象方法.

      

      一个接口去继承并实现多个接口的例子如下:  

interface A   
{   
    public void printA() ;   
}   
interface B   
{   
    public void printB() ;   
}   
interface C extends A,B   
{   
    public void printC() ;   
}   
class X implements C   
{   
    // 如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法   
    public void printA()   
    {   
        System.out.println("A --> HELLO") ;   
    }   
    public void printB()   
    {   
        System.out.println("B --> HELLO") ;   
    }   
    public void printC()   
    {   
        System.out.println("C --> HELLO") ;   
    }   
}   
public class Demo04   
{   
    public static void main(String args[])   
    {   
        X x = new X() ;   
        x.printA() ;   
        x.printB() ;   
        x.printC() ;   
    }   
} 
interface A 
{ 
public void printA() ; 
} 
interface B 
{ 
public void printB() ; 
} 
interface C extends A,B 
{ 
public void printC() ; 
} 
class X implements C 
{ 
// 如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法 
public void printA() 
{ 
   System.out.println("A --> HELLO") ; 
} 
public void printB() 
{ 
   System.out.println("B --> HELLO") ; 
} 
public void printC() 
{ 
   System.out.println("C --> HELLO") ; 
} 
} 
public class Demo04 
{ 
public static void main(String args[]) 
{ 
   X x = new X() ; 
   x.printA() ; 
   x.printB() ; 
   x.printC() ; 
} 
}

    

?

   3.4 这里,如果一个子类既要继承一个抽象类,又要实现一个接口,该怎么写呢?

       我们采取的是: class 类名称 extends 抽象类 implements 接口 这样的语法格式.

      下面是同时继承一个抽象类,又实现接口的具体实例:    

interface X   
{   
    public void printX() ;   
}   
interface Z   
{   
    public void printZ() ;   
}   
// 一个抽象类也是可以实现接口的   
abstract class Y implements Z   
{   
    public abstract void printY() ;   
}   
// D类同时继承Y类和实现X接口   
class D extends Y implements X   
{   
    public void printX()   
    {   
        System.out.println("X --> HELLO .") ;   
    }   
    public void printY()   
    {   
        System.out.println("Y --> HELLO .") ;   
    }   
    public void printZ()   
    {   
        System.out.println("Z --> HELLO .") ;   
    }   
}   
public class Demo13   
{   
    public static void main(String args[])   
    {   
        D d = new D() ;   
        d.printX() ;   
        d.printY() ;   
        d.printZ() ;   
    }   
}

  

?
18天Java学习---15.面向对象编程10-Java中final关键字,抽象类与接口
JXES智能生态系统
01-05 1276
抽象类与接口是Java中最重要部分之一,这里用较大的篇幅来做下这部分的笔记. 1. final关键字 在Java中, 可以使用final关键字修饰类、方法以及成员变量。 (1).final标记的类不能被继承; (2).final标记的方法不能被子类复写; (3).final标记的变量即成为常量,只能被赋值一次. 注意: 如果...
java中的final关键字、抽象类及接口的定义
RYJ359的博客
07-23 1381
final关键字 final：最终的       final：可以修饰 方法、成员变量、局部变量。       final  修饰类，则该类不能有子类 final   修饰方法：该方法不能被重写(覆盖)       final  修饰局部变量，其值不能被改变，即该变量只能被赋值一次； 成为常量(此时变量名通常用大写字母表示，称为字符串常量)。      final  修饰成员变量：如
Java 抽象类和Final关键字
weixin_30321709的博客
03-26 126
抽象类 用abstract关键字来修饰一个类时，这个类叫抽象类； 用abstract关键字来修饰一个方法时，该方法叫做抽象方法。 含有抽象方法的类必须被定义而为抽象类，抽象类必须被继承，抽象方法必须被重写。 抽象类不能被实例化。 抽象方法只需要被声明，而不需要实现。 abstract class Animal { private String name; Animal(Stri...
java中的final关键字和java抽象类
weixin_30772261的博客
07-31 112
1.final关键字 final --- finally 最终的 最后的 不能再变化的 final的作用： ）.1.final修饰变量，成为常量，值不能再变化）.2.final修饰方法，不能被子类重写）.3.final修饰类，不能再有子类(final中的方法即使不使用final修饰，也不能被重写) final不能修饰构造方法 引入： Java中提供了哪些final常量、...
Java中的final关键字 和 Java中的抽象类
xlh006的博客
10-09 401
Java中的final关键字 使用final声明的类不能被继承； 使用final声明的方法不能被子类覆盖； 使用final声明的变量不能被修改，即为常量； Java中的抽象类 定义：在java中，含有抽象方法的类称为抽象类，抽象类不能生成对象； 注意点： 1，包含抽象方法的类是抽象类； 2，抽象类和抽象方法都要用abstract关键字修饰； 3，抽象方法只需要声明而不需要实现； ...
Java面向对象抽象类关键字----abstract
NSSWTT的博客
01-04 678
Java面向对象中抽象类关键字（abstract）的基础运用 //abstract 抽象关键字！ /* * 注意：abstract只能修饰类和方法！ * 特点： * 1.抽象方法必须放在抽象类中 * 2.抽象方法省略{ }，只需声明方法即可！ * 3.抽象类--->被子类继承--->创建对象（其实就是抽象类不可以new对象） ...
面向对象(四)：this关键字，final关键字，抽象类，接口
12-22
Java中提供了 this 关键字来指代当前对象，用于在方法中访问对象的其他成员。 通过 this 关键字调用成员方法，解决与局部变量名称冲突问题 package com.wang.demo1; public class Person { int age; //成员变量 age...
Java面向对象深入：final关键字、抽象类与接口解析
面向对象编程10-Java中final关键字,抽象类与接口" 在Java编程语言中，`final`关键字、抽象类和接口是面向对象设计的重要概念，它们帮助开发者创建灵活且可扩展的代码结构。 1. `final`关键字 `final`关键字在Java...
java中final关键字使用示例详解
09-04
6. **final与抽象类（abstract）** - `final`和`abstract`是相互排斥的，一个类不能同时是`final`和`abstract`，因为`final`表示不允许继承，而`abstract`则表示需要被继承。 7. **接口中的final变量** - 在接口...
Java学习笔记---15.面向对象编程10-Java中final关键字,抽象类与接口
11-24
在Java编程语言中，`final`关键字、抽象类和接口是面向对象编程的重要概念。它们各自扮演着不同的角色，帮助我们构建更健壮、可维护的代码结构。 首先，`final`关键字在Java中具有多种用途。它可以用来修饰类、方法...
java中用关键字什么指明抽象_java 中用关键字( )指明抽象类,用关键字( )指明接口。_学小易找答案...
weixin_35924773的博客
02-23 276
【单选题】已知 int i = 2147483647; ++i; 则 i 的值等于( )。【填空题】执行下列代码后的结果是什么 ? int x,a=8,b=4,c=5; x=++a+b+++c++; x = ( ) , a = ( ) , b = ( ), c = ( )【填空题】Scanner 类在( )包下面。【填空题】正面投影是由 前 向 后 投射所得的图形,又称 视图。...
java中用关键字什么指明抽象_JavaSE核心技术-面向对象高级特性
weixin_33072399的博客
02-23 320
面向对象主要特征继承(inheritance)继承也称泛化，继承性是子类自动共享父类属性和方法的机制。是类之间的的一种关系，一般类与特殊类之间的关系。关键字extends*被继承的类称为父类(超类，基类)，继承的类叫子类(派生类)。*子类继承父类的所有属性和方法，同时也可以增加自己的属性和方法。语法为：【修饰符】class 子类名 extends 父类名例：图片.png继承的含义*java中只...
java abstract 关键字 抽象方法和抽象类的使用详解
码农回顾
10-27 6286
java abstract class 抽象类的使用详解
个人测试五
qq_44188658的博客
03-02 2729
选择题：1.下面关于import, class和package的声明顺序哪个正确？( A )2.下面哪个是正确的？( D )3.关于java.lang.String类，以下描述正确的一项是（ A）String类是final的，在java中final修饰类的不能被继承4.关于实例方法和类方法，以下描述正确的是：(D )A 实例方法可以访问类变量 B类方法只能访问类变量 C类方法可以通过对象调用5.接口是Java面向对象的实现机制之一，以下说法正确的是：( B )Java支持单重继承，一个类只能继承自另外的一个
java abstract static_总结下java中abstract,interface,final,static,加深理解
weixin_32916125的博客
02-16 177
关键字: abstract, interface, final, static一,抽象类:abstract1,只要有一个或一个以上抽象方法的类,必须用abstract声明为抽象类;2,抽象类中可以有具体的实现方法;3,抽象类中可以没有抽象方法;4,抽象类中的抽象方法必须被它的子类实现,如果子类没有实现,则该子类继续为抽象类5,抽象类不能被实例化,但可以由抽象父类指向的子类实例来调用抽象父类中的具体...
final、抽象类、接口细节
最新发布
weixin_69077668的博客
07-31 272
final： 1、final 可以修饰类（表示不允许继承），属性（表示不允许修改），方法（表示不允许重写），不能修饰构造器 2、经final修饰的属性会变为常量，必须得赋初值，可在定义时，构造器内，代码块内 3、如果final修饰的属性是static的，可赋初值的位置有：定义时，静态代码块内，不能在构造器内 （静态属性在类加载执行，而构造器在创建对象实例时才执行，） 4、static final连用不会导致类加载 5、包装类例如Integer等都是final类，都是不能被继承的 抽象类： 1、abst
final关键字和接口interface
xiaoxixuewu的博客
08-01 719
作为常量：常量的书写规范所有字母都大写，如果由多个单词组成单词间通过“_”连接 三： public static void main(String[] args) { //new BaseStudent().study(); new Student().study(); } } class Student{ void study() { } } class ...
浅谈为什么Java接口中不允许定义变量
clam_clam的专栏
07-20 3627
接口就是提供一种统一的“协议”，而接口中的属性也属于“协议”中的成员。它们是公共的，静态的，最终的常量。相当于全局常量。抽象类是不“完全”的类，相当于是接口和具体类的一个中间层。即满足接口的抽象，也满足具体的实现。　　如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无
final关键字可以用来修饰类、方法、变量、参数，不能修饰抽象类和接口
热门推荐
zhaotengfei36520的专栏
04-17 4万+
面试题  以下关于final关键字说法错误的是（A,C）（两项） A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B) final修饰的类肯定不能被继承 C) final修饰的方法不能被重载 D) final修饰的变量不允许被再次赋值 一、final关键字可以用来修饰类、方法、变量。各有不同。 A、修饰类(class)。       1、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值