final关键字
- final用于声明属性,方法和类,可以修饰类,修饰字段,修饰方法,修饰局部变量,修饰形参
- 属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期不能修改,
- 修饰修饰类,最终类,不能被继承,不能被定义为抽象类或者接口
- 修饰字段,必须显示初始化,不能被修改,一般final与static同时修饰某个字段,所有字母都大写,表示final常量
- 修饰方法:bueng子类不能被覆盖 能被子类继承
- 修饰局部变量, 一旦初始化就不能再修改, 注意final修饰引用类型变量, 是指这个引用类型变量不能再指向其他对象,可以修饰它的属性值
- 修饰方法形参, 在方法体中不能修改final形参的值
final属性赋值:
–在声明时同时赋值,往往与static一起使用
final static int Num = 10;
package com.nie.day5.demo06;
public class Filal {
//用于声明方法和类
//final修饰常量,常量值不能变,利用static 修饰 节省空间
final static int Num = 10;
final int a = 100;
public final void eat() {
System.out.println("你好");
}
//定义就必须直接赋值或者在构造方法中进行中进行赋值,后期不能修改
public void num(int a) {
// this.a=1000;
System.out.println(a);
}
//在方法参数前加final关键字,防止数据在方法题中被修改.
public void num1(final int b) {
// b=11;
}
}
抽象类
为什么定义抽象类?
- 如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类
- 抽象类除了不能实例化对象之外,类的其他功能依然存在,名成变量,成员方法和构造方法的访问方式和普通类一样.
如何定义抽象类
- 用abstract修饰的类就是抽象类,如果某个类中包含抽象方法,那么这个类就必须定义抽象类.
为什么定义抽象方法:
当一个类的某个操作无法具体实现时,这个操作可以定义为抽象方法,使用abstract修饰方法, 只有方法的声明, 没有方法体
- 抽象方法时一种特殊的方法:他只有声明,而没有具体的实现
- 抽象方法必须用abstract关键字进行修饰
如何使用抽象类
- 抽象类一般作为其他类的父类存在,
- 子类继承了抽象类,子类需要重写抽象类中所有的抽象方法,如果没有重写所有的抽象方法子类也需要为定义抽象方法
注意:
抽象类中不一定含有抽象方法
- 抽象类可以有成员属性和非抽象方法
- 抽象类不能被实例化,但可以有构造函数.因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象
- 抽象类不能创建对象:抽象类只能做基类,表示一种继承关系.
- 构造方法和静态方法不可以用abstract,
abstract与final不共存
- 因为abstract不能实例bai化（没有构造方法），du需要有子类zhi来实现，而final为“最终的”，修饰类时表示不能被继承既没有子类，这两个就矛盾了。
但是呢，一个abstract类里面可以有final关键字存在，前提是这个final修饰的方法必须在abstract类中已经实现，作用是继承它的子类不能重写这个方法
[访问权限] abstract class 类名 {
成员列表
}
public abstract class Shapes {
public abstract void draw();
}
public abstract class Shapes {
public void draw(){
//具体代码
}
}然后我们定义个抽象类
抽象类无法被直接实例化，我们可以让子类继承然后实例化子类
然后我们实例化子类
接口
接口的基本概念:
Java中只支单继承,如果向定义一些功能,想让一个子类都能继承实现,提供接口,这样我们就可以用一个子类去实现多个接口.**.可以理解为接口时特殊的抽象类.**这种抽象类中只包含常量和方法的定义,没有变量和方法的实现.
接口设计时候:关系实现类有何做哟个,不关心内部细节,面向接口的约定而不考虑接口的具体实现.
接口的定义:
public interface Animal1 {
//所有属性默认为: public static final
void eat1();
//所有方法都是：public abstract
void foo();
}- 定义接口: interface
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n] {
// 声明常量
// 抽象方法
}- 接口使用 :implements
[访问修饰符] class 类名 implements 接口名1，接口名2……{ }- 结合继承：
[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }接口的特性:接口不能被实例化,实现类必须重写接口的所有方法,实现类可以实现多个接口,接口中的变量都是静态.
接口一
/**
* 本质上说接口就是一个抽象类,
* 抽象类中只包含常量和方法的定义,
* 没有变量和方法的实现
*/
public interface animal extends Animal1 {
//所有属性默认为 public static final
// public static final int age=10;
//变量必须赋值
int age = 10;
//默认的为public abstract
//抽象方法访问时必须进行重写
void eat();
public abstract void test();
//jdk8后接口可以使用默认方法,和静态方法
//比抽象方法更加灵活,根据功能方法进行选择
public default void test1() { //被子类重写
System.out.println("默认方法");
}
public static void test2() {//通过类名访问4
System.out.println("静态方法");
}
}
接口二
public interface Animal1 {
//所有属性默认为: public static final
void eat1();
//所有方法都是：public abstract
void foo();
}接口三
public interface Animal2 {
void test3();
}类
//定义为抽象类 或者
//重写抽象方法
/**
* 一个类可以实现多个接口,
* <p>
* 一个类可以实现继承一个类
* 但是可以实现多个接口
*/
public class Dog implements animal, Animal1, Animal2 {
//抽象方法访问时必须进行重写
@Override
public void eat() {
System.out.println("抽象方法\t吃");
}
@Override
public void test() {
System.out.println("抽象方法测试");
}
@Override
public void eat1() {
}
@Override
public void foo() {
}
@Override
public void test3() {
}
}
测试
public class Test {
public static void main(String[] args) {
Dog dog =new Dog();
dog.eat();
dog.test();
dog.test1();//默认方法//
animal.test2();//静态方法
}
}接口的特性:
- 接口是特殊的抽象类,当声明一个接口的时候必须要声明abstract关键字
- 接口中每一个方法也是隐式抽象的,默认public abstract 。jdk8以后有默认和静态方法 public static 方法, public default方法
- 接口中声明的属性默认为 public static final
- 接口不能被继承,要被实现implements
- 接口不能实例化对象(灭有构造方法),但是可以声明对象的引用(多态性)
- 有接口多有多态。多态的条件（子类重写父类方法，继承，父类引用指向子类对象）因为接口中有抽象方法，所以必须要重写，实现（implements）可以理解为在接口环境下继承（extends）的另一个名字
- 多个类可以使用一个接口
- 一个类可以实现多个接口,但只能继承一个类
- 一个类可以继承多个接口,使用关键字extends，可以继承多个接口，使用 逗号 分割
- 在类实现接口的时候,类要实现接口的所有方法,或者类必须设置为抽象类
- 接口体现的是is-a的关系
接口的好处
- 快速增强子类功能,符合面向对象的思想
- 可扩展性强,当需要增强原有类的功能不需要修改原有类的代码,只需要增加接口.
接口和抽象类的区别:
区别
- 抽象类可以构造方法,接口不可以
- 抽象类可以有普通成员变量,抽象类不行
- 抽象类有非抽象的普通方法,而接口中所有的方法必须是抽象的(jdk8以后有默认和静态方法)
- 抽象类中的抽象方法访问类型可以是public ，protected和默认类型,但接口中的抽象方法只能是public类型的
- 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义静态常量。
不同点:
- 意义不同
- 抽象类是对事物更高层级的抽象
- 接口是对功能的封装
- 定义方式不同
- 抽象类用 abstract class定义
- 接口用interface定义
- 内容不同
- 抽象类中除了抽象方法外,还可以定义构造方法等普通类中定义的所有成员
- 接口除了抽象方法等这四个内容外, 不能定义构造方法等内容
public abstract修饰, 接口中还可以定义public static final常量 , public static 方法, public default方法
- 使用方式不同
- 抽象类需要被子类extends继承
- 接口需要被实现类implements实现
- 类只支持单继承, 接口支持多继承
- 应用场景不同
- 一般情况下, 对类进行功能的扩展,优先选择接口
- 除了扩展功能外, 还需要保存不同的数据,只能选择抽象类;
- 抽象类的抽象方法需要子类重写,
- 抽象类还可以约束所有的子类都具有相同的功能.
相同点:
1)都可以定义抽象方法
2)都不能实例化对象,创建对象
3)定义的抽象方法都需要被重写
4)都可以定义public static方法, public static final常量