JavaSE基础加强、进阶语法

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() {
    //存在接口冲突
    }
}

飞翔的企鹅i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE基础加强、进阶语法

目录一、包1、什么是包？2、建包的语法格式3、导包二、权限修饰符1、什么是权限修饰符？2、权限修饰符的分类和具体作用范围3、学完权限修饰符具备能力三、final1、final的作用 2、final修饰变量注意事项四、常量1、常量的基本概述2、常量做信息标准的分类五、枚举1、枚举概述2、定义枚举的格式 3、枚举的特征4、枚举使用场景演示六、抽象类1、抽象类的基础知识2、抽象类的使用场景 3、抽象类的特征和注意事项4、final和abstract是什么关系?5、模板方法模式什么时候使用模板方法模式模板方法实现
复制链接

扫一扫

专栏目录