final关键字的功能使用
【1】修饰变量;
final修饰一个变量,变量的值不可以改变,这个变量也变成了一个字符常量
final int A = 10;//final修饰基本数据类型
//A = 20; 报错:不可以修改值
第2种情况:
final修饰引用数据类型,那么地址值就不可以改变
final Dog d = new Dog();
//d = new Dog(); -->地址值不可以更改
//d对象的属性依然可以改变:
【2】修饰方法;
final修饰方法,那么这个方法不可以被该类的子类重写
【3】修饰类;
final修饰类,代表没有子类,该类不可以被继承:
1、 一旦一个类被final修饰,那么里面的方法也没有必要用final修饰了(final可以省略不写)
2、 里面的属性全部被final修饰,方法也是被final修饰的,只是省略不写了
3、 外界不可以创建对象:
4、 类中的所有的属性,方法都被static修饰
那么不用创建对象去调用,只能通过类名.属性名 类名.方法名 去调用
抽象类和抽象方法
【1】抽象类和抽象方法的关系:
抽象类中可以定义0-n个抽象方法
【2】抽象类作用:
在抽象类中定义抽象方法,目的是为了为子类提供一个通用的模板,
子类可以在模板的基础上进行开发,先重写父类的抽象方法,然后可以扩展子类自己的内容。
抽象类设计避免了子类设计的随意性,通过抽象类,子类的设计变得更加严格,
进行某些程度上的限制。使子类更加的通用。
【3】代码:
1、一个类中如果有方法是抽象方法,那么这个类也要变成一个抽象类。
2、一个方法的方法体去掉,然后被abstract修饰,那么这个方法就变成了一个抽象方法
public abstract void say();
public abstract void sleep();
3、抽象类可以被其他类继承:
(1)一个类继承一个抽象类,那么这个类可以变成抽象类
(2)一般子类不会加abstract修饰,一般会让子类重写父类中的抽象方法
4、子类继承抽象类,就必须重写全部的抽象方法
5、子类如果没有重写父类全部的抽象方法,那么子类也可以变成一个抽象类。
【4】面试题:
(1)抽象类不能创建对象,那么抽象类中是否有构造器?
抽象类中一定有构造器。构造器的作用 给子类初始化对象的时候要先super调用父类的构造器。
(2)抽象类是否可以被final修饰?
不能被final修饰,因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了,就不存在继承了,就没有子类。
接口interface
【1】接口声明格式:
[访问修饰符] interface 接口名 [extends 父接口1,父接口2…] {
常量定义;
方法定义;
}
【2】接口与类:
- 1.类是类,接口是接口,它们是同一层次的概念。
- 2.接口中没有构造器
- 3.接口如何声明:interface
- 4.在JDK1.8之前,接口中只有两部分内容:
- (1)常量:固定修饰符:public static final
- (2)抽象方法:固定修饰符:public abstract
- 注意:修饰符可以省略不写,默认不写也在
public interface TestInterface01 {
//常量:
/*public static final*/ int NUM = 10;
//抽象方法:
/*public abstract*/ void a();
/*public abstract*/ void b(int num);
/*public abstract*/ int c(String name);
}
interface TestInterface02{
void e();
void f();
}
提取知识点:
1、 类和接口的关系是什么?
实现关系 类实现接口
2、 一旦实现一个接口,那么实现类要重写接口中的全部的抽象方法
3、 如果没有全部重写抽象方法,那么这个类可以变成一个抽象类。
4、 java只有单继承,但有多实现
- 一个类继承其他类,只能直接继承一个父类
- 但是实现类实现接口的话,可以实现多个接口
5、 写法:先继承 再实现:
extends Person implements TestInterface01,TestInterface02
class Student extends Person implements TestInterface01,TestInterface02 {
@Override
public void a() {
System.out.println("---1");
}
@Override
public void b(int num) {
System.out.println("---2");
}
}
class Test{
public static void main(String[] args) {
//接口不能创建对象:
//TestInterface02 t = new TestInterface02();
TestInterface02 t = new Student();//接口指向实现类 ---》多态
//接口中常量如何访问:
System.out.println(TestInterface01.NUM);
System.out.println(Student.NUM);
}
【3】接口的作用是什么?
定义规则,只是跟抽象类不同地方在哪?它是接口不是类。
接口定义好规则之后,实现类负责实现即可。
【4】
继承:子类对父类的继承
实现:实现类对接口的实现
【5】多态的应用场合:
(1)父类当做方法的形参,传入具体的子类的对象
(2)父类当做方法的返回值,返回的是具体的子类的对象
(3)接口当做方法的形参,传入具体的实现类的对象
(4)接口当做方法的返回值,返回的是具体的实现类的对象
【6】接口和抽象类的区别:
JDK1.8以后的接口新增内容
在JDK1.8之前,接口中只有两部分内容:
(1)常量:固定修饰符:public static final
(2)抽象方法:固定修饰符:public abstract
在JDK1.8之后,新增非抽象方法:
(1)被public default修饰的非抽象方法:
注意1:default修饰符必须要加上,否则出错
注意2:实现类中要是想重写接口中的非抽象方法,那么default修饰符必须不能加,否则出错。
public interface TestInterface {
//常量:
public static final int NUM= 10;
//抽象方法:
public abstract void a();
//public default修饰的非抽象方法:
public default void b(){
System.out.println("-------TestInterface---b()-----");
}
}
class Test implements TestInterface{
public void c(){
//用一下接口中的b方法:
b();//可以
//super.b();不可以
TestInterface.super.b();//可以
}
@Override
public void a() {
System.out.println("重写了a方法");
}
@Override
public void b() {
}
}
(2)静态方法:
注意1:static不可以省略不写
注意2:静态方法不能重写
public interface TestInterface2 {
//常量:
public static final int NUM = 10;
//抽象方法:
public abstract void a();
//public default非抽象方法;
public default void b(){
System.out.println("-----TestInterface2---b");
}
//静态方法:
public static void c(){
System.out.println("TestInterface2中的静态方法");
}
}
class Demo implements TestInterface2{
@Override
public void a() {
System.out.println("重写了a方法");
}
public static void c(){
System.out.println("Demo中的静态方法");
}
}
class A {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
Demo d = new Demo();
d.c();
Demo.c();
TestInterface2.c();
}
}
疑问:为什么要在接口中加入非抽象方法???
如果接口中只能定义抽象方法的话,那么我要是修改接口中的内容,那么对实现类的影响太大了,所有实现类都会受到影响。
现在在接口中加入非抽象方法,对实现类没有影响,想调用就去调用即可。
内部类
类的组成:
属性,方法,构造器,代码块(普通块,静态块,构造块,同步块),内部类
内部类:成员内部类 (静态的,非静态的) 和 局部内部类(位置:方法内,块内,构造器内)
内部类功能:
- 内部类可以访问外部类的内容
- 内部类和外部类属性重名的时候,使用 外部类名. this. 关键字进行调用:
- 外部类想要访问内部类的东西,需要创建内部类的对象然后进行调用
- 静态内部类中只能访问外部类中被static修饰的内容
- 在局部内部类中访问到的变量必须是被final修饰的
public class TestOuter {
//非静态的成员内部类:
public class D{
int age = 20;
String name;
public void method(){
//5.内部类可以访问外部类的内容
/*System.out.println(age);
a();*/
int age = 30;
//8.内部类和外部类属性重名的时候,如何进行调用:
System.out.println(age);//30
System.out.println(this.age);//20
System.out.println(TestOuter.this.age);//10
}
}
//静态成员内部类:
static class E{
public void method(){
//6.静态内部类中只能访问外部类中被static修饰的内容
/*System.out.println(age);
a();*/
}
}
//属性:
int age = 10;
//方法:
public void a(){
System.out.println("这是a方法");
{
System.out.println("这是一个普通块");
class B{
}
}
class A{
}
//7.外部类想要访问内部类的东西,需要创建内部类的对象然后进行调用
D d = new D();
System.out.println(d.name);
d.method();
}
static{
System.out.println("这是静态块");
}
{
System.out.println("这是构造块");
}
//构造器:
public TestOuter(){
class C{
}
}
public TestOuter(int age) {
this.age = age;
}
}
class Demo{
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//创建外部类的对象:
TestOuter to = new TestOuter();
to.a();
//9.创建内部类的对象:
//静态的成员内部类创建对象:
TestOuter.E e = new TestOuter.E();
//非静态的成员内部类创建对象:
//错误:TestOuter.D d = new TestOuter.D();
TestOuter t = new TestOuter();
TestOuter.D d = t.new D();
}
}