1、final## 标题
final修饰的类不可以被继承,是一个最终类,
final修饰的方法是最终的方法,不可以被重写,但可以被继承使用
final修饰的变量不可以被修改值
2、stati## 标题
static可以定义静态的属性,可以通过类共享,被static修饰的是在加载类的时候就被加载到静态区,
static修饰的类,方法,成员变量都可以通过类名直接使用
package com.itheima.demo05static;
/*
定义每个学生特有的成员(非静态)
只有一种使用方式:创建对象,访问属性,调用方法
定义每个学生共享的成员(静态)
有两种使用方式:
1.创建对象,访问属性,调用方法(不推荐,占用内存,效率低)
2.静态的成员属于类,所以我们可以通过类名直接使用
类名.静态成员变量
类名.静态的成员方法(参数);
*/
public class Student {
//定义非静态的成员变量
int a = 10;
//定义静态成员变量
static int b = 20;
//定义非静态的成员方法
public void show01(){
System.out.println("Student类的非静态show01方法!");
}
//定义静态的成员方法
public static void show02(){
System.out.println("Student类的静态show02方法!");
}
}
测试类
package com.itheima.demo05static;
public class Demo01Student {
public static void main(String[] args) {
//创建Student对象
Student s = new Student();
System.out.println(s.a);
System.out.println(s.b);
s.show01();
s.show02();
//静态的成员,通过类名可以直接使用
System.out.println(Student.b);
Student.show02();
Student.b = 200;
System.out.println(Student.b);
Demo01Student.method();
//同一个类中,使用静态的成员,可以省略类名
method();
}
public static void method(){
System.out.println("静态的method方法!");
}
}
3、接口## 标题
接口就是定义一些功能的规范,是一些类的特有属性,谁实现接口,谁就拥有该接口的功能
接口里必须定义抽象方法,因为接口中没有抽象方法的话,接口就没有实际的意义,
接口的格式是interface,接口不能创建对象,
下面是接口的具体使用:
package com.itheima.demo06interface;
/*
定义使用含有抽象方法的接口(重点)
抽象方法:没有方法体,被abstract修饰的方法
定义格式:
public abstract 返回值类型 方法名(参数);
注意:
1.接口中的抽象方法修饰符是可以省略不写的,不写默认也是public abstract
建议写出,增强阅读性
-----------------------------
接口的使用:
1.接口是不能创建对象使用
2.可以定义一个实现类,实现(继承)接口,重写接口中的抽象方法,创建实现类对象使用
*/
public interface MyInter {
//定义抽象方法
//public abstract void show01();
//abstract void show01();
void show01();
public abstract int show02();
public abstract void show03(String s);
}
package com.itheima.demo06interface;
/*
定义接口的实现类
使用格式:使用实现类实现接口,重写接口中的抽象方法
public class 实现类名 implements 接口{
重写接口中的抽象方法
}
注意:
实现类似于继承,类实现接口,就可以继承接口中所有的非私有方法
*/
public class MyInterImpl implements MyInter{
@Override
public void show01() {
System.out.println("实现类重写接口中的show01抽象方法!");
}
@Override
public int show02() {
System.out.println("实现类重写接口中的show02抽象方法!");
return 0;
}
@Override
public void show03(String s) {
System.out.println("实现类重写接口中的show03抽象方法!"+s);
}
}
package com.itheima.demo06interface;
public class Demo01MyInter {
public static void main(String[] args) {
//'MyInter' is abstract; cannot be instantiated 接口不能创建对象使用
//MyInter my = new MyInter();
//创建接口的实现类对象
MyInterImpl my = new MyInterImpl();
my.show01();
my.show02();
my.show03("张靓颖");
}
}
类与类之间只能单继承,类与类之间可以多重继承,类可以同时实现多个接口
package com.itheima.demo06interface;
public class Demo01MyInter {
public static void main(String[] args) {
//'MyInter' is abstract; cannot be instantiated 接口不能创建对象使用
//MyInter my = new MyInter();
//创建接口的实现类对象
MyInterImpl my = new MyInterImpl();
my.show01();
my.show02();
my.show03("张靓颖");
}
}
package com.itheima.demo09abstractInterface;
//定义含有抽象方法的接口
public interface B {
public abstract void b();
public abstract void show();
}
package com.itheima.demo09abstractInterface;
/*
接口的多实现:类可以同时实现多个接口
格式:
public class 实现类 implements 接口1,接口2,接口3....接口n{
重写所有接口中的抽象方法
}
注意:
接口中含有抽象方法,实现类需要重写所有接口的抽象方法
如果接口中有同名的抽象方法,实现类只重写一个就可以了
不会产生不确定性,抽象方法没有方法体
*/
public class AandBImpl implements A,B{
@Override
public void a() {
System.out.println("实现类重写A接口中的抽象a方法!");
}
@Override
public void b() {
System.out.println("实现类重写B接口中的抽象b方法!");
}
@Override
public void show() {
System.out.println("实现类重写A接口和B接口中的抽象show方法!");
}
}
package com.itheima.demo09abstractInterface;
public class Demo01 {
public static void main(String[] args) {
//创建接口的实现类对象使用
AandBImpl ab = new AandBImpl();
ab.a();
ab.b();
ab.show();
}
}
抽象类和接口的区别