一、关键字
final和static
final关键字可以修饰成员变量、方法、类,修饰后相当于不可变,无法被重新赋值、重写、继承
static关键字可以修饰成员变量和方法,修饰成员之后被放在类的堆内存中,被修饰的成员和方法可以通过类名.成员名/方法名直接调用
public、private、protected、default
这是用来处理公开私密关系的关键字
extends、interface、implements
这是用来处理声明继承关系、声明接口、声明实现接口的关键字
class star extends Math //声明star继承Math
interface star //声明star为接口
class star implements Math //声明star为接口Math的实现类
abstract
使用 abstract 关键字修饰方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。
继承抽象类的子类必须重写父类所有的抽象方法。否则,该子类也必须声明为抽象类。最终,必须有子类实现该父类的抽象方法,否则,从最初的父类到最终的子类都不能创建对象,失去意义。
- 抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。 - 抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。 - 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类
super、this
这是在类中处理应用关系的关键字
super :代表父类的存储空间标识(可以理解为父亲的引用)。
this :代表当前对象的引用(谁调用就代表谁)
public class Math {
//finnl修饰,不可改变值
final int nnum=100;
//static修饰,为类变量
static int nsum=0;
int n;
public Math(){
System.out.println("无参数构造方法");
}
public Math(int n){
//编译器报错,numn已经被final修饰,为不可变变量,被static修饰是可以变化的
//this.nnum=n;
this.n=n;
System.out.println("含参构造函数");
}
public void show(){
System.out.println("这是数学方法");
}
public void display(String name){
System.out.println("数学还有一个称呼"+name);
}
}
class star extends Math{
int n3;
//此处继承父类构造方法,需要传递给父类构造函数
public star(int n2,int n3){
super(n2);
//将传入构造函数的变量给当前对象的全局变量
this.n3=n3;
}
public void play(){
System.out.println("这是用来演示this的一个方法");
}
public void show(){
//无参数父类引用
super.show();
//无参数当前对象应用
this.play();
}
public void display(String name){
//含参数父类对象引用
super.display(name);
}
}
二、继承、多态、抽象类、内部类
继承
子类可以继承父类中所有未被private关键字保护的属性、方法,以此达到复用
子类可以重写父类方法,也可以有自己的方法
子类中可以使用super关键字调用父类属性、方法
多态
多态定义: 是指同一行为,具有多个不同表现形式
体现一:重载
同一方法有多种形式,参数不同实现不同
public Math(){
System.out.println("无参数构造方法");
}
public Math(int n){
System.out.println("含参构造函数");
}
public Math(int n,int s){
System.out.println("这也是含参构造函数");
}
体现二:数据类型引用执行子类方法
父类类型 对象名 = new 子类类型();
变量名.方法名();
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,执行的是子类重写后方法。
类型为父类,使用子类方法
封装类
//父类
public abstract class Animal {
public abstract void eat(){
System.out.println("吃瓜");
}
}
//子类Cat
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}
//子类Dog
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
测试类
public class Test {
public static void main(String[] args) {
// 多态形式,创建对象
Animal a1 = new Cat();
// 调用的是 Cat 的 eat
a1.eat();
// 多态形式,创建对象
Animal a2 = new Dog();
// 调用的是 Dog 的 eat
a2.eat();
}
}
体现三:数据类型引用参数传递
实际开发的过程中,父类类型作为方法形式参数,传递子类对象给方法,
进行方法的调用,更能体现出多态的扩展性与便利。
public class Test {
public static void main(String[] args) {
// 多态形式,创建对象
Cat c = new Cat();
Dog d = new Dog();
// 调用showCatEat
showCatEat(c);
// 调用showDogEat
showDogEat(d);
showAnimalEat(c);
showAnimalEat(d);
}
public static void showCatEat (Cat c){
c.eat();
}
public static void showDogEat (Dog d){
d.eat();
}
/*
以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
而执行效果一致
*/
public static void showAnimalEat (Animal a){
a.eat();
}
}
抽象类
关键字abstract已经说明
abstract
内部类
类的内部中的类
三、接口
概述:
接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法(JDK 9)
接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
引用数据类型:数组,类,接口。
接口的使用,它不能创建对象,但是可以被实现( implements ,类似于被继承)。一个实现接口的类(可以看做是接口的子类),需要实现接口中所有的抽象方法,创建该类对象,就可以调用方法了,否则它必须是一个抽象类
格式
public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
实现
类与接口的关系为实现关系,即类实现接口,
该类可以称为接口的实现类,也可以称为接口的子类。
实现的动作类似继承,格式相仿,只是关键字不同,实现使用 implements 关键字。
非抽象子类实现接口:
1. 必须重写接口中所有抽象方法。
2. 继承了接口的默认方法,即可以直接调用,也可以重写。
私有方法:只有默认方法可以调用。
私有静态方法:默认方法和静态方法可以调用。
接口
public interface Person {
//抽象方法
public abstract void marry();
//静态方法
public static void speak(){
System.out.println("人类都会吃饭");
}
//默认方法
public default void run(){
System.out.println("The people run!");
}
}
实现
public class People implements Person {
//此处写构造方法
People(String name){
System.out.println("我的名字是"+name);
}
public void eat(){
System.out.println("我只负责吃!");
}
//此处重写抽象类
public void marry(){
System.out.println("不是所有人都想结婚的!");
}
//此处可以重写,也可以继承
}