1. 包

1.1 什么是包？

包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。建包的语法格式：package 公司域名倒写.技术名称。报名建议全部英文小写，且具备意义

建包语句必须在第一行，一般IDEA工具会帮助创建

1.2 导包

相同包下的类可以直接访问，不同包下的类必须导包,才可以使用！导包格式：import 包名.类名; 假如一个类中需要用到不同类，而这个两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问。

2. 权限修饰符

2.1 什么是权限修饰符？

权限修饰符：是用来控制一个成员能够被访问的范围。

可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。

2.2 权限修饰符的分类和具体作用范围：

权限修饰符：有四种作用范围由小到大（private -> 缺省 -> protected - > public ）

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

2.3 学完权限修饰符需要具备如下能力

能够识别别人定义的成员的访问范围。自己定义成员（方法，成员变量，构造器等）一般需要满足如下要求：成员变量一般私有。方法一般公开。如果该成员只希望本类访问，使用private修饰。如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰。

package modifer;

public class fu {
    //1.private
    private void privateMethod() {
        System.out.println("private");
    }

    //2.缺省
    void Method() {
        System.out.println("private");
    }

    //3.protected
    protected void protectedMethod() {
        System.out.println("protected");
    }

    //4.public
    public void publicMethod() {
        System.out.println("public");
    }

    public static void main(String[] args) {
        fu f = new fu();
        f.Method();;
        f.privateMethod();
        f.publicMethod();
        f.protectedMethod();
    }
}

package modifer.itcast;

import modifer.fu;

public class zi extends  fu {
    public static void main(String[] args) {
        zi z =new zi();
        z.protectedMethod();
        z.publicMethod();


    }
}

package modifer;

public class Test {
    public static void main(String[] args) {
        //权限修饰符作用范围
        fu f = new fu();
        f.Method();
        f.protectedMethod();
        f.publicMethod();
    }
}

package modifer.itcast;

import modifer.fu;

public class Test2 {
    public static void main(String[] args) {
        fu f = new fu();
        f.publicMethod();
        //  f.Method();报错
        //f.protectedMethod();报错
        // f.privateMethod();报错
    }
}

3. final

3.1 final的作用

final 关键字是最终的意思，可以修饰（类、方法、变量）修饰类：表明该类是最终类，不能被继承。修饰方法：表明该方法是最终方法，不能被重写。修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)

3.2 final修饰变量的注意

final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。 final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

package d3_final;

public class Test {
    //记住final语法
    //final 关键字是最终的意思，可以修饰（类、方法、变量）
    //修饰类：表明该类是最终类，不能被继承。
    //修饰方法：表明该方法是最终方法，不能被重写。
    //修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。
}

class Student extends  People{
 //   @Override
 //   public   void eat(){
  //      System.out.println("学生吃的多");
  //  }
}
class People{
    public  final void eat(){
        System.out.println("人吃饭");
    }
}
//class wolf extends Animal{}
//final  class  Animal{}

package d3_final;

public class Test2 {
    // 2.成员变量（实例成员变量和静态成员变量）
    public static final String school = "外事";
    //实例成员变量和静态成员变量
    private  final  String name = "小明";//几乎不用
    public static void main(String[] args) {

        //理解final修饰变量
        //1.局部变量
        final double rate = 3.12;
       // school ="西安"; 二次赋值
        //rate = 2.33;//二次赋值不行
        Test2 t = new Test2();
        System.out.println(t.name);
        //t.name = "张三"; 不能二次赋值
        //重点： final 引用类型地址不可以改变 指向对象内容可以改变
    final    Teacher T = new Teacher("学习，上课，吃饭");
    //T2 = null;
        System.out.println(T.getHobby());
        T.setHobby("运动");
        System.out.println(T.getHobby());


    }
}
class  Teacher{
    private String hobby;

    public Teacher(String hobby) {
        this.hobby = hobby;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

4 常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。常量名的命名规范：英文单词全部大写，多个单词下划线连接起来。常量的作用：通常用来记录系统的配置数据。

4.1 常量做信息配置的原理、优势

在编译阶段会进行“宏替换”：把使用常量的地方全部替换成真实的字面量。维护系统容易，可读性更好。

package d4_constant;

public class Demo {
    public  static  final String SCHOOL_NAME = "外事学院";
    public  static  final String UESR_NAME = "外事学院";
    public  static  final String PASS_WORD= "外事学院";
    public static void main(String[] args) {
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        if(UESR_NAME.equals("")){

        }
    }
}

4.2 案例说明：超级玛丽游戏

现在开发的超级玛丽游戏需要接收用户输入的四个方向的信号（上下左右），以便控制玛丽移动的方向。

选择常量做信息标志和分类：代码可读性好，实现了软编码形式。

package d4_constant;

public class Constant {
    /**
     常量类：配置类
     */
        public static final int UP = 1;
        public static final int DOWN = 2;
        public static final int LEFT = 3;
        public static final int RIGHT = 4;
    }

package d4_constant;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Demo2 {
    public static void main(String[] args) {



            // 目标：理解常量的另外一个作用：做信息的标志和分类。
            // 模拟：控制玛丽的移动：上下左右。
            // 桌面编程
            // 1、创建窗口
            JFrame win = new JFrame("超级玛丽");
            win.setSize(300, 200);

            // 2、设计一个面板（桌布）
            JPanel jPanel = new JPanel();
            win.add(jPanel);

            // 2、放置几个按钮
            JButton b1 = new JButton("上");
            jPanel.add(b1);
            b1.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // 控制玛丽往上跳
                    move(Constant.UP);
                }
            });

            JButton b2 = new JButton("下");
            jPanel.add(b2);
            b2.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // 控制玛丽往下蹲
                    move(Constant.DOWN);
                }
            });

            JButton b3 = new JButton("左");
            jPanel.add(b3);
            b3.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // 控制玛丽往左走
                    move(Constant.LEFT);
                }
            });

            JButton b4 = new JButton("右");
            jPanel.add(b4);
                    b4.addActionListener(new ActionListener() {
                        @Override
                        public void actionPerformed(ActionEvent e) {
                            // 控制玛丽往右走
                    move(Constant.RIGHT);
                }
            });

            win.setLocationRelativeTo(null);
            win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
            win.setVisible(true);
        }

        public static void move(int orientation){
            // 控制玛丽移动
            switch (orientation) {
                case Constant.UP:
                    System.out.println("玛丽往↑飞了一下~~");
                    break;
                case Constant.DOWN:
                    System.out.println("玛丽往↓蹲了一下~~");
                    break;
                case Constant.LEFT:
                    System.out.println("玛丽往←跑了一下~~");
                    break;
                case Constant.RIGHT:
                    System.out.println("玛丽往→跑了一下~~");
                    break;
            }
        }
    }

5 枚举

5.1枚举的概述

枚举是Java中的一种特殊类型枚举的作用："是为了做信息的标志和信息的分类"。定义枚举类的格式：enum Season{ SPRING , SUMMER , AUTUMN , WINTER;}

5.2 枚举特征：

枚举类都是继承了枚举类型：java.lang.Enum 枚举都是最终类，不可以被继承。构造器都是私有的，枚举对外不能创建对象。枚举类的第一行默认都是罗列枚举对象的名称的。枚举类相当于是多例模式。

6 抽象类

6.1 抽象的使用场景

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。

6.2 抽象类、抽象方法是什么样的？

都是用abstract修饰的；抽象方法只有方法签名，不能写方法体。一个类中定义了抽象方法，这个类必须声明成抽象类。

6.3抽象类基本作用是啥？

作为父类，用来被继承的。

6.4 继承抽象类有哪些要注意？

一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

package d5_abstract;
//抽象类
public  abstract  class Animal {
    //抽象方法
    public abstract  void run();
}

package d5_abstract;

public class Dog  extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑的快");
    }
}

package d5_abstract;

public class Test {
    public static void main(String[] args) {
        //认识抽象类
        //父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类
        Dog D= new Dog();
        D.run();

    }
}

6.4 系统需求加油站

某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡 ,后续加油享受8.5折优惠。请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额，支付功能。

package d7_abstract;

public abstract class Card {
    private String  username;
    private  double money;

    //定义支付方法
    //抽象方法不能给方法体
    public abstract void pay(double money);

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

package d7_abstract;

public class GoldCard  extends  Card{

    @Override
    public void pay(double money) {
        System.out.println("您当前消费： "+ money);
        System.out.println("您当前消费余额 "+ getMoney());
        double rs = money*0.8;
        System.out.println("您实际支付： "+rs);
        setMoney(getMoney() - rs);

    }
}

package d7_abstract;

public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000);
        c.setUsername("张三");

        c.pay(300);
        System.out.println(c.getUsername()+"账户剩余余额："+c.getMoney());
        //您当前消费： 300.0
        //您当前消费余额 10000.0
        //您实际支付： 240.0
        //张三账户剩余余额：9760.0

    }
}

6.5 特征和注意事项

类有的成员（成员变量、方法、构造器）抽象类都具备抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。不能用abstract修饰变量、代码块、构造器。最重要的特征：得到了抽象方法，失去了创建对象的能力（有得有失）

package d8_abstract;

public class Test {
    public static void main(String[] args) {
        //类有的成员（成员变量、方法、构造器）抽象类都具备
        //抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
        //一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
        //不能用abstract修饰变量、代码块、构造器。
        //最重要的特征：得到了抽象方法，失去了创建对象的能力（有得有失）
        //原因 ： 反证法 加入抽象类可以创造对象
        //Animal a = new Animal();
        //a.run();//run方法都没有方法体
      //  Card c= new Card();//抽象方法不允许创造对象
    }
}
abstract  class Card{
    private  String name;
}
class cat extends  Animal{

    @Override
    public void run() {

    }

    @Override
    public void eat() {

    }
}
abstract class Animal{
    public abstract  void run();
    public abstract  void eat();


}

6.7 final和abstract是什么关系？面试题

互斥关系 abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

7 模板方法模式

7.1 理解模板方法：写作文案例

package d9_abstract;
//模板方法
public abstract  class Student {
    public  final  void write() {

        System.out.println("\t《我的爸爸》");
        System.out.println("我的爸爸啥样");
        //正文部分
        //把正文部分定义成抽象方法交给子类完成
        System.out.println(WriteMain());

        System.out.println("我的爸爸太好了");
    }
    public  abstract String WriteMain();
}

package d9_abstract;

public class StudentChild extends  Student{

    @Override
    public String WriteMain() {
        return "我的爸爸太牛了";
    }
}

package d9_abstract;

public class StudentMiddle extends  Student {

    @Override
    public String WriteMain() {
        return "我的爸爸会飞";
    }
}

7.2 模板方法模式解决了什么问题？

提高了代码的复用性模板方法已经定义了通用结构，模板方法不能确定的部分定义成抽象方法，交给子类实现，因此，使用者只需要关心自己需要实现的功能即可。

package d9_abstract;

public class Test {
    public static void main(String[] args) {
        StudentMiddle s = new StudentMiddle();
        s.write();
        StudentChild s2 = new StudentChild();
        s2.write();
        // 《我的爸爸》
        //我的爸爸啥样
        //我的爸爸会飞

package d9_abstract;

public class Test {
    public static void main(String[] args) {
        StudentMiddle s = new StudentMiddle();
        s.write();
        StudentChild s2 = new StudentChild();
        s2.write();
        // 《我的爸爸》
        //我的爸爸啥样
        //我的爸爸会飞
        //我的爸爸太好了
        // 《我的爸爸》
        //我的爸爸啥样
        //我的爸爸太牛了
        //我的爸爸太好了
    }
}

        //我的爸爸太好了
        // 《我的爸爸》
        //我的爸爸啥样
        //我的爸爸太牛了
        //我的爸爸太好了
    }
}

8 接口

8.1 接口是一种规范规范一定是公开的

package d10_interface;
//声明了一个接口
public interface Demo {
    //1.常量
    public static  final String SCHOOL_NAME= "外事";
    //2.抽象方法
    //接口是公开的，所以public static 可以不写
     void  run();
   // public  abstract  void  run();
  void  eat();
  //  public  abstract  void  eat();

}

8.2 类和接口多实现

package d11_implements;

public class Test {
    public static void main(String[] args) {
        //被类实现
        PingPongMan p = new PingPongMan("张继科");
        p.run();
        p.competition();
        p.rule();
        //张继科必须跑步
        //张继科必须比赛
        //张继科必须守法
    }
}

package d11_implements;

public interface SportMan {
    void  run();
    void  competition();
}

package d11_implements;
//实现类
public class PingPongMan implements  SportMan,Law {
    private  String name;

    public PingPongMan(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name +"必须跑步");

    }

    @Override
    public void competition() {
        System.out.println(name+"必须比赛");

}

    @Override
    public void rule() {
        System.out.println(name+"必须守法");
    }
}

package d11_implements;

public class Test {
    public static void main(String[] args) {
        //被类实现
        PingPongMan p = new PingPongMan("张继科");
        p.run();
        p.competition();
        p.rule();
        //张继科必须跑步
        //张继科必须比赛
        //张继科必须守法
    }
}

8.3 接口的基本使用

接口是用来被实现的，实现接口的类型称为实现类

类和类单继承；

接口和接口多继承

package d12_exends;

public interface Law {
    void run();
}

package d12_exends;

public interface People {
    void eat();
}

package d12_exends;

public interface SportMan extends Law,People{
    void heh();
}

package d12_exends;

public class Ball implements Law,People,SportMan {
    @Override
    public void run() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void heh() {

    }
}

8.4 JDK8开始接口新增方法开发一般不用

接口不能创造对象

一个类实现多个接口，多个接口有同样的静态方法不冲突；

一个类继承了父类，同时又实现了接口，父类中的接口有同名的方法，默认用父类的

package d13_inface;

public interface SportMainter {
    //1.默认方法
    //接口不能创造对象，过继给了实现类，实现类对象才可以调用
   default  void run(){
       go();
       System.out.println("跑得快");
}
//2.静态方法 static修饰
    //必须接口名自己调用
    static  void  inAdd() {
        System.out.println("今天下雨了");}

        //3.私有方法
        //接口内部使用 必须自己调用
        private void go () {
            System.out.println("跑");
    }
  
}
class PingPong implements  SportMainter{

}
class Test{
    public static void main(String[] args) {
        PingPong p = new PingPong();
        p.run();

        SportMainter.inAdd();
    }
}

本文含有隐藏内容，请开通VIP 后查看

Java 面向对象进阶

1. 包

1.1 什么是包？

1.2 导包

2. 权限修饰符

2.1 什么是权限修饰符？

2.2 权限修饰符的分类和具体作用范围：

2.3 学完权限修饰符需要具备如下能力

3. final

3.1 final的作用

3.2 final修饰变量的注意

4 常量

4.1 常量做信息配置的原理、优势

4.2 案例说明：超级玛丽游戏

5 枚举

5.1枚举的概述

5.2 枚举特征：

6 抽象类

6.1 抽象的使用场景

6.2 抽象类、抽象方法是什么样的？

6.3抽象类基本作用是啥？

6.4 继承抽象类有哪些要注意？

6.4 系统需求加油站

6.5 特征和注意事项

6.7 final和abstract是什么关系？面试题

7 模板方法模式

7.1 理解模板方法：写作文案例

7.2 模板方法模式解决了什么问题？

8 接口

8.1 接口是一种规范规范一定是公开的

8.2 类和接口多实现

8.3 接口的基本使用

8.4 JDK8开始接口新增方法开发一般不用

网站公告

今日签到

热门文章

最新发布

Java 面向对象进阶

1. 包

1.1 什么是包？

1.2 导包

2. 权限修饰符

2.1 什么是权限修饰符？

2.2 权限修饰符的分类和具体作用范围：

2.3 学完权限修饰符需要具备如下能力

3. final

3.1 final的作用

3.2 final修饰变量的注意

4 常量

4.1 常量做信息配置的原理、优势

4.2 案例说明：超级玛丽游戏

5 枚举

5.1枚举的概述

5.2 枚举特征：

6 抽象类

6.1 抽象的使用场景

6.2 抽象类、抽象方法是什么样的？

6.3抽象类基本作用是啥？

6.4 继承抽象类有哪些要注意？

6.4 系统需求 加油站

6.5 特征和注意事项

6.7 final和abstract是什么关系？面试题

7 模板方法模式

7.1 理解模板方法：写作文案例

7.2 模板方法模式解决了什么问题？

8 接口

8.1 接口是一种规范 规范一定是公开的

8.2 类和接口多实现

8.3 接口的基本使用

8.4 JDK8开始接口新增方法 开发一般不用

网站公告

今日签到

热门文章

最新发布

6.4 系统需求加油站

8.1 接口是一种规范规范一定是公开的

8.4 JDK8开始接口新增方法开发一般不用