目录
一、包
1、什么是包?
2、建包的语法格式
3、导包
二、权限修饰符
1、什么是权限修饰符?
2、权限修饰符的分类和具体作用范围
3、学完权限修饰符具备能力
三、final
1、final的作用
2、final修饰变量注意事项
四、常量
1、常量的基本概述
2、常量做信息标准的分类
五、枚举
1、枚举概述
2、定义枚举的格式
3、枚举的特征
4、枚举使用场景演示
六、抽象类
1、抽象类的基础知识
2、抽象类的使用场景
3、抽象类的特征和注意事项
4、final和abstract是什么关系?
5、模板方法模式
什么时候使用模板方法模式
模板方法实现的步骤
模板方法解决了什么问题?
七、接口
1、什么是接口
2、接口的基本使用:被实现
3、接口与接口的关系:多继承
接口多继承的作用:
4、JDK8开始接口新增方法
1、默认方法 (实例方法)
2、静态方法
3、私有方法
5、接口的注意事项:
一、包
1、什么是包?
包是用来分门别类的管理各种不同类的,类似于文件夹、建包利于程序的管理和维护。
2、建包的语法格式
package 公司域名倒写.技术名称。包名建议全部小写,且具备意义。
package com.itheima.this_super;
3、导包
相同包下的类可以直接访问,不同包下的类必须导包才可以使用。
导包格式:
import com.itheima.this_super;
package com.itheima.day01_package;
import com.itheima.day01_package.test.Test1;
public class Test {
public static void main(String[] args) {
//相同包下的类可以访问
System.out.println(User.a);
//不同包下的类要导包
System.out.println(Test1.b);
//如果这个类中使用不同包下的相同的类名,此时默认只能导入一个类的包,另一个类要使用全名访问
com.itheima.day01_package.test2.Test1 test1 = new com.itheima.day01_package.test2.Test1();
}
}
二、权限修饰符
1、什么是权限修饰符?
- 权限修饰符:用来控制一个成员能够被访问的范围。
- 可以修饰成员变量、方法、构造器、内部类,不同权限修饰符修饰的成员能够被访问的范围将受到限制。
2、权限修饰符的分类和具体作用范围
权限修饰符的四种作用范围,由小到大为:
private > 缺省(default) > protected > public
缺省:没有修饰符 (包访问权限)
继承了父类的类为子类。
3、学完权限修饰符具备能力
三、final
1、final的作用
- final关键字是最终的意思,可以修饰(类、方法、变量)。
- final修饰类:表明该类是最终类,不能被继承。
- final修饰方法:表明该方法是最终方法,不能被重写。
- final修饰变量:表示该变量第一次赋值后,不能再次被赋值(并需要赋值,但只能被赋值一次)。
变量分为:局部变量和成员变量。成员变量分为:实例成员变量和静态成员变量。
2、final修饰变量注意事项
- final修饰的变量是基本类型:那么变量存储的数据值不能发生改变。
- final修饰的变量是引用类型:那么变量存储的地址值不能发生改变,但是地址指向的对象内容是可以发生变化的
//仍然可以修改指向对象的内容
final Teacher t = new Teacher("爱好");
t.setHobby("修改");
四、常量
1、常量的基本概述
2、常量做信息标准的分类
例如在使用switch语句中,使用case1,case2表意不明,可以通过常量,定义有意义的常量赋值为1,2,使代码可读性好,实现了软编码。
五、枚举
1、枚举概述
枚举是java中的一种特殊类型。
枚举的作用:“是为了做信息的标志和信息的分类”。
枚举类是Java中的一种类,它有有限个不同实例对象,又叫多例模式
2、定义枚举的格式
3、枚举的特征
4、枚举使用场景演示
public class Test {
//定义方法调用这个枚举类
public enum EnumTest {
//枚举第一行必须罗列枚举类型的对象名称,建议全部大写
//可以定义多个对象
UP,DOWN,LEFT,RIGHT;
}
public static void move(EnumTest e){
switch (e) {
case UP:
break;
case DOWN:
break;
case LEFT:
break;
case RIGHT:
break;
}
}
//方法调用move方法的内容
public void d1(){
//通过枚举类名调用
move(EnumTest.UP);
}
}
六、抽象类
1、抽象类的基础知识
在java中abstract是抽象的意思,可以修饰类或者成员方法。
abstract修饰类,这个类就是抽象类;修饰方法,这个方法就是抽象方法。
快速生成抽象方法:alt+Enter。
//一个类如果定义了抽象方法,这个类必须声明成抽象类,否则报错
public abstract class Animal {
//抽象方法只有方法签名,不能声明方法体
public abstract void dog();
}
抽象类就相当于一个雏形的模具,用来让其他子类来继承这个模具,在这个模具的基础上创建新的东西。
继承的子类必须对抽象父类进行方法重新,否则报错,除非子类也是抽象类。
//对抽象类Animal进行继承
public class Dog extends Animal{
//对抽象父类进行重写
@Override
public void run() {
System.out.println("狗跑得快");
}
}
2、抽象类的使用场景
3、抽象类的特征和注意事项
- 类有的东西(成员变量、成员方法、构造器),抽象类都有
- 抽象类中可以没有抽象方法,有抽象方法的类一定是抽象类
- 一个类继承了抽象类必须重写完抽象类的全部抽象方法,否则这个类也必须定义成抽象类
- 不能用abstract修饰变量、代码块、构造器
最重要的特征 :得到了抽象方法,失去了创建对象的能力 (有得有失)
抽象就是不能创建对象。
4、final和abstract是什么关系?
互斥关系
final修饰类,类不能被继承;abstract修饰类,类必须被继承。
abstract定义的抽象方法必须让子类重写,final定义的方法不能被重写。
5、模板方法模式
什么时候使用模板方法模式
使用场景:当系统中出现同一个 功能在多处开发,而该功能中大部分代码是一样的,只有其中部分可能不同
模板方法实现的步骤
- 把功能定义成一个所谓的模板方法,放在抽象类中,模板方法中只定义通用且能确定的代码。
- 模板方法中不能决定的功能定义成抽象方法让具体子类去实现。
//定义一个模板
public abstract class Student {
//模板方法用final修饰更专业,不允许重写
public final void write() {
System.out.println("标题");
System.out.println("第一段");
/*
*正文部分(每个子类都要写的,每个子类写的情况不一样)
* 因此,通过模板方法模式把正文定义成抽象方法,交给
* 具体的子类来完成
*/
//正文
writeMain();
System.out.println("结尾");
}
protected abstract void writeMain();
}
//创建子类继承这个模板
public class MiddleWritting extends Student{
@Override
protected void writeMain() {
System.out.println("中学生正文");
}
}
//测试
public class Test {
public static void main(String[] args) {
MiddleWritting m = new MiddleWritting();
m.write();
}
}
//结果
标题
第一段
中学生正文
结尾
模板方法建议使用final修饰,这样会更专业,因为模板方法是给子类直接使用的,不是让子类重写的,一旦子类重写了模板方法,则模板方法就失效了,因此加上final修饰可以防止子类重写模板方法。
模板方法解决了什么问题?
- 提高了代码的复用性
- 模板方法已经定义了通用结构,模板方法不能确定的部分定义成抽象方法,交给子类实现,因此,使用者只需要关心自己需要实现的功能即可。
七、接口
1、什么是接口
接口也是一种规范,约束设计方式。规范一定是要公开
public interface Demo {
//1、常量
String SCHOOL_NAME = "黑那";
//会自动生成 public static final String SCHOOL_NAME = "黑那";
//可以省略不写,但要知道他是常量
//2、抽象方法
//public abstract void run();
//也可以不写,默认会设置
void run();
}
2、接口的基本使用:被实现
接口是用来被类实现(implements)的,实现接口的类称为实现类。实现类可以理解成所谓的子类。
接口可以被类单实现,也可以被多实现。
注意:
一个类实现接口,必须重写完全部接口的全部抽象方法,否则这个类需要定义成抽象类。
3、接口与接口的关系:多继承
- 类和类的关系:单继承。
- 类和接口的关系:多实现。
- 接口和接口的关系:多继承,一个接口可以同时继承多个接口。
接口多继承的作用:
规范合并,整合多个接口为同一个接口,便于子类实现。
4、JDK8开始接口新增方法
允许接口中直接定义带有方法体的方法。
1、默认方法 (实例方法)
- 类似之前写的普通实例方法:必须用default修饰
- 默认会public修饰,需要用接口的实现类的对象来调用
public interface Sport {
/* 1、默认方法(实例方法)
---必须使用default修饰,public可以省略
---默认方法,接口不能创建对象,这个方法只能过继给了实现类,由实现类的对象调用
*/
public default void run(){
System.out.println("跑得很快");
}
}
//实现类
class PingMan implements Sport {
//接口没有定义抽象类,所以实现类不用操作
}
//test
class Test{
public static void main(String[] args) {
PingMan p = new PingMan();
p.run();
}
}
2、静态方法
- 默认会public修饰,必须用static修饰
- 接口的静态方法必须用本身的接口名来调用,不允许子类调用父类的静态方法。
public interface Sport {
/* 2、静态方法
---必须使用static修饰,默认用public修饰
---public可以省略
---接口的静态方法,必须接口名自己调用
*/
public static void run(){
System.out.println("java新增语法");
}
}
//实现类
class PingMan implements Sport {
//接口没有定义抽象类,所以实现类不用操作
}
//test
class Test{
public static void main(String[] args) {
//静态方法只能接口名自己调用
Sport.run();
}
}
3、私有方法
- 就是私有的实例方法:必须使用private修饰,从JDK1.9才开始有。
- 只能在本类中被其他默认方法或者私有方法访问。
public interface Sport {
/* 2、私有方法(实例方法)
---jdk1.9开始
---必须是default修饰的实例方法
*/
public default void run(){
go();
System.out.println("跑得很快");
}
private void go(){
//必须在接口的内部才能被访问
System.out.println("开始跑");
}
}
//实现类
class PingMan implements Sport {
//接口没有定义抽象类,所以实现类不用操作
}
//test
class Test{
public static void main(String[] args) {
//静态方法只能接口名自己调用
PingMan p = new PingMan();
p.run();
}
}
5、接口的注意事项:
- 接口不能创建对象(接口更加彻底的抽象)。
- 一个类实现多个接口,多个接口中有同样的静态方法不冲突。
- 一个类继承了父类,同时又实现了接口,父类中和接口中有同名方法,默认用父类的。
public class Comment {
public static void main(String[] args) {
//一个类继承了父类,同时又实现了接口,父类中和接口中有同名方法,默认用父类的。
Cat c = new Cat();
c.eat();
}
}
interface Food{
default void eat(){
System.out.println("接口中的吃");
}
}
class Animal{
public void eat(){
System.out.println("父类动物吃");
}
}
//相当于子类有一个亲爸和多个干爹
//亲爸必须放在干爹前,继承在前,实现在后
class Cat extends Animal implements Food{
}
- 一个类实现了多个接口,多个接口中存在同名的默认方法,不冲突,这个类重写该方法即可。
interface A{
default void go(){
System.out.println("AA");
}
}
interface B{
default void go(){
System.out.println("BB");
}
}
class C implements A,B{
@Override
public void go() {
//一个类实现了多个接口,多个接口中存在同名的默认方法
//子类只能使用自己重写的方法,无法使用A,B的go方法
}
}
- 一个接口继承多个接口,是没有问题的,如果多个接口中存在规范冲突则不能继承。
interface A{
//有返回值的a方法
int a();
}
interface B{
//无返回值的a方法
void a();
}
class C implements A,B{
@Override
public int a() {
//存在接口冲突
}
}