抽象类与接口是Java中最重要部分之一,这里用较大的篇幅来做下这部分的笔记.
1. final关键字
在Java中, 可以使用final关键字修饰类、方法以及成员变量。
(1).final标记的类不能被继承;
(2).final标记的方法不能被子类复写;
(3).final标记的变量即成为常量,只能被赋值一次.
注意: 如果使用final来声明常量,请遵守以下常规: final标记的变量名,所有单词字母都需大写.
--------------------------------------------------------------------------------
2. 抽象类
讲抽象类的定义必须先讲抽象方法的定义. 所谓抽象方法,是指只声明而未实现(即没有{}包围的方法体)的方法. 而含有一个或多个抽象方法的类就称为抽象类.
抽象类 = 普通类 + 抽象方法
对于抽象类,时刻需要谨记: 抽象类是不能够直接实例化的, 如果要使用一个抽象类,就必须要有该抽象类的子类. 如果抽象类的子类不是抽象类的话,就一定要复写该抽象类的所有抽象方法.
如下面代码示例: view plaincopy to clipboardprint?
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([参数列表])指明要调用父类中的哪个构造方法.
这里举例如下: view plaincopy to clipboardprint?
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)多个接口. 如果实现接口的类不是抽象类的话,则该子类必须复写接口中所有的抽象方法.
例如如下代码示例: view plaincopy to clipboardprint?
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). 既然定义中已经明确说明了接口是抽象方法和全局变量的集合,因此,我们可以如下例一样,对代码进行简化: view plaincopy to clipboardprint?
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关键字去继承一个或多个已有的接口,但在子类的实现时,也必须全部实现所有接口的抽象方法.
一个接口去继承并实现多个接口的例子如下: view plaincopy to clipboardprint?
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 接口 这样的语法格式.
下面是同时继承一个抽象类,又实现接口的具体实例: view plaincopy to clipboardprint?
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() ;
}
}
1. final关键字
在Java中, 可以使用final关键字修饰类、方法以及成员变量。
(1).final标记的类不能被继承;
(2).final标记的方法不能被子类复写;
(3).final标记的变量即成为常量,只能被赋值一次.
注意: 如果使用final来声明常量,请遵守以下常规: final标记的变量名,所有单词字母都需大写.
--------------------------------------------------------------------------------
2. 抽象类
讲抽象类的定义必须先讲抽象方法的定义. 所谓抽象方法,是指只声明而未实现(即没有{}包围的方法体)的方法. 而含有一个或多个抽象方法的类就称为抽象类.
抽象类 = 普通类 + 抽象方法
对于抽象类,时刻需要谨记: 抽象类是不能够直接实例化的, 如果要使用一个抽象类,就必须要有该抽象类的子类. 如果抽象类的子类不是抽象类的话,就一定要复写该抽象类的所有抽象方法.
如下面代码示例: view plaincopy to clipboardprint?
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([参数列表])指明要调用父类中的哪个构造方法.
这里举例如下: view plaincopy to clipboardprint?
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)多个接口. 如果实现接口的类不是抽象类的话,则该子类必须复写接口中所有的抽象方法.
例如如下代码示例: view plaincopy to clipboardprint?
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). 既然定义中已经明确说明了接口是抽象方法和全局变量的集合,因此,我们可以如下例一样,对代码进行简化: view plaincopy to clipboardprint?
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关键字去继承一个或多个已有的接口,但在子类的实现时,也必须全部实现所有接口的抽象方法.
一个接口去继承并实现多个接口的例子如下: view plaincopy to clipboardprint?
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 接口 这样的语法格式.
下面是同时继承一个抽象类,又实现接口的具体实例: view plaincopy to clipboardprint?
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() ;
}
}
发表评论
-
Servlet
2010-08-20 11:28 5021.什么是Servlet? ... -
MyEclipse快捷键
2010-08-20 11:27 524存盘 Ctrl+s(肯定知道) 注释代码 Ctrl+/ 取 ... -
java面试题
2010-08-20 11:26 479第一,谈谈final, finally, finalize的区 ... -
Java学习笔记---16.面向对象编程11-Java多态性,instanceof及Object类
2010-08-20 11:26 694多态是一个之前一直搞不清楚的概念,通过这次笔记,对多态的概念及 ... -
Java学习笔记---14.面向对象编程09-Java中重载与复写的区别、super与this的比较
2010-08-20 11:22 8221. 方法重载与方法复写的区别 区别 ... -
Java学习笔记---13.面向对象编程08-Java中继承的概念,子类实例化过程,super()及方法复写
2010-08-20 11:12 1004继承是OOP的三大特点之一. 这一节主要做一下继承的笔记. ... -
Java学习笔记---12.面向对象编程07-Java中的static关键字用法
2010-08-20 11:08 857static关键字应用点有3个: static变量(属性)的声 ... -
Java学习笔记---11.面向对象编程06-Java的内部类及对象数组
2010-08-20 11:04 8301. Java的内部类机制 所谓内部类,是指在一 ... -
java学习笔记---10.面向对象编程05-面向对象程序的设计步骤
2010-08-20 11:03 776这一部分需要注意一个原则, 熟练掌握OOP的程序设计方法. ... -
Java学习笔记---9.面向对象编程04-this关键字的使用
2010-08-20 11:00 734Java学习笔记---9.面向对象编程04-this关键字的使 ... -
Java学习笔记---8.面向对象编程03-String类的重点应用
2010-08-20 10:59 698在String类这一部分很重要,分为三个问题来做笔 ... -
Java学习笔记---7.面向对象编程02-类的封装性以及构造方法
2010-08-20 10:57 7971. 类的封装特性: 类的封装性是指类 ... -
Java学习笔记---6.面向对象编程01-类对象的构建及对象的引用传递
2010-08-20 10:54 671Java学习笔记---6.面向对象编程01-类对象的构建及对象 ... -
Java学习笔记---5.Java数组和方法
2010-08-20 10:53 7221. 数组的声明语法 Java中数组的声明有两种形 ... -
Java学习笔记---4.Java的分支循环语句
2010-08-20 10:51 692switch的使用如下例: view plain ... -
Java学习笔记---3.运算符与表达式
2010-08-20 10:49 683这一部分需要再强调的东西不多,因为运算符表达式都是平时最常用的 ... -
Java学习笔记---2.Java标识符和基本数据类型
2010-08-20 10:48 933这一块里面,标识符比较简单,没有什么需要记录的东西. ... -
Java学习笔记---1.Java发展及JDK配置
2010-08-20 10:47 770Java的老东家是Sun公司(Sun的全名,Stanford ...
相关推荐
JAVA学习笔记-java学习笔记WORD样式.docx
Java基础每日复习笔记-JavaSE高级阶段.2020-10-13-211312.edf
Java 版设计模式学习笔记-java-design-patterns
Java并发编程与高并发解决方案-学习笔记-www.itmuch.com
学习笔记-微机原理与接口技术.pdf
Java学习笔记-面向对象-001-面向对象概括 还会继续上传后续文本 详情访问http://www.feifeiblog.com/
6.1. 面向对象与面向过程 6-11 6.2. 对象的概念 6-12 6.3. 成员变量和局部变量 6-12 6.4. 成员方法 6-12 6.5. This关键字 6-13 6.6. 访问控制符 6-13 6.7. 构造方法 6-13 6.8. 数据和方法的隐藏―――封装 6-14 6.9....
-抽象类、接口 -final.作业评讲 -作业、测试题 -数组 -排序、查找 -二进制、位运算、位移运算 -集合 -集合 -集合 -集合补充 -异常 -面试题评讲 -布局管理器 -常用组件 -swing编程实战 -绘图技术.坦克大战2 -事件处理...
JavaSE 之前整理的笔记,一共16章:1.Java概述,2....面向对象4(抽象类 接口 包装类),8.GUI编程--awt,9.GUI编程--计算器案例,10.GUI编程--Swing,11.集合,12.多线程,13.IO流,14.网络编程,15.JDBC编程,16.异常处理
Java学习笔记->1.关键字、变量以及常量.md
java学习笔记--PrintStream分享.pdf
Java学习笔记-Java后来者.exe
java学习笔记---从入门到精通之路.pdf
2023-04-06-项目笔记-第一阶段- 11.操作符 11.1操作符的使用 12.常见关键字 12.1关键字 typedef 12.2关键字static 12.2.1修饰局部变量 12.2.2修饰全局变量 12.2.3修饰函数 13.#define 定义常量和宏 14.指针 14.1内存...
LaTex教程--latex排版学习笔记---入门提高.pdf
JAVA学习笔记,java知识点总结
新版Android开发教程&笔记--基础入门一.pdf 新版Android开发教程&笔记--基础入门二.pdf 新版Android开发教程&笔记三--环境搭建与解析.pdf 新版Android开发教程&笔记四--Dalvik ADB.pdf 新版Android开发教程+笔记五--...
【JAVA】笔记(8)--- java.lang.String 精讲(csdn)————程序