前言

前面我们用sublime Text记事本学习了面向对象初级的内容，从这一章节开始，我们正式使用idea集成开发工具，学习和锻炼更为复杂的编程能力，同时也是对面向对象内容的更深度学习，包括包、封装、继承、重写、多态、转型、断点调试等内容。

受篇幅限制，本篇文章是韩顺平老师课程P264-P296（第8章：面向对象编程中级）上半部分重点内容的详细总结。

1. IDEA常用快捷键与模板
2. 包的使用与规范
3. 访问修饰符
4. 封装（重点）
5. 继承（重点）

一、IDEA

使用

• out 文件夹 存放 编译后的 .class文件
• src 文件夹 存放 源码文件 .java 文件

常用快捷键

1. 删除当前行（默认是ctrl+y，可以自己配置）
   ctrl+d
2. 复制当前行（自己配置）
   ctrl+alt+下光标
3. 补全代码
   alt+/
4. 添加注释和取消注释（第一次是添加注释，第二次是取消注释）
   ctrl+/

• 如何修改快捷键
  

5. 导入该行需要的类
   • 先配置auto import
     
   • 然后使用alt+enter
6. 快速格式化代码
   ctrl+alt+L
7. 快速运行程序（自己定义）
   alt+R
8. 生成构造器等 alt + insert [提高开发效率]
   
   
9. 查看一个类的层级关系 ctrl + H [学习继承后，非常有用]
10. 将光标放在一个方法上，输入 ctrl + B , 可以定位到方法 [学继承后，非常有用]
11. 自动的分配变量名 , 通过 在后面 + .var

模板/自定义模板

• main + 回车
• sout + 回车
• fori + 回车
  

二、包package

1. 基本介绍

• 一个应用场景：两个程序员都想定义一个类，名为Dog

• 包的三大作用

  • 区分相同名字的类
  • 当类很多时，可以很好地管理类（查看API文档）
  • 控制访问范围

• 基本语法

package com.hspedu;
//1.package 关键字，表示打包
//2.com.hspedu 表示包名
com 是一级目录  hspedu 是下一级目录

• 原理：实际上就是创建不同的文件夹（目录）来保存类文件
  
• 快速入门
  
  

2. 包的命名规范

• 命名规则：只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字
  
• 命名规范：一般是小写字母 + 小圆点
  

3. 常用的包和如何引入

• 常用的包
  一个包下，包含很多的类，java 中常用的包有:

  • java.lang.*
    lang 包是基本包，默认引入，不需要再引入
  • java.util.*
    util 包，系统提供的工具包, 工具类，使用 Scanner
  • java.net.*
    网络包，网络开发
  • java.awt.*
    是做 java的界面开发GUI

• 如何引入包

  • 语法：import 包；
  • 主要目的：使用该包下面的一个类
    比如importjava.util.Scanner; 就只是引入一个类Scanner
    import java.util.*; 表示将java util 包所有都引入
  • 案例：使用系统自带类进行排序
    

4. 注意事项和细节

• package 的作用是声明当前类所在的包，需要放在class的最上面，一个类最多只有一句package
• import 指令 位置放在package的下面，在类定义前面，可以有多句且没有顺序要求
  

三、访问修饰符（四类）

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

• 公开级别: 用 public 修饰, 对外公开

• 受保护级别: 用 protected 修饰,对子类和同一个包中的类公开

• 默认级别: 没有修饰符号, 向同一个包的类公开

• 私有级别: 用 private 修饰, 只有类本身可以访问, 不对外公开

• 同类中，都可以使用
  

• 同包中，私有无法访问 只有n1, n2, n3 可选
  

• 子类中，只能访问 public 和 protected

• 不同包中，只有 public 类可以访问，只有n1可以选 use包 和 qiang包
  

四、封装Encapsulation（重点）

1. 封装介绍

• 面向对象编程三大特征：封装、继承和多态

• 封装（encapsulation）就是把抽象的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作

• 封装的理解和好处

  • 隐藏实现细节：方法<–调用
  • 可以对数据进行验证，保证安全合理

2. 封装步骤

• 将属性进行私有化 private 【不能直接修改属性】
• 提供一个公共的 (public) set方法，用于对属性判断并赋值
• 提供一个公共的get方法，用于获取属性的值

3. 快速入门

package com.mucy.encap;

public class Encapusulation01 {

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("jack");
        person.setAge(33);
        person.setSalary(30000);
        System.out.println(person.info());
    }
}

class Person {
    public String name;
    private int age;
    private double salary;

   /* public void setName(String name) {
        this.name= name;
    }
    public String getName() {
        return name;
    } */
    //自己写set xxx  get xxx 太慢，用快捷键
    //Alt + insert 选择setter and getter

    //对代码进行完善
    public String getName() {
        return name;
    }
    public void setName(String name) {
        //加入对数据的校验
        if(name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("名字有误");
            this.name = "无名";
        }
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("信息有误");
            this.age = 22;
        }
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    //写一个方法，返回属性信息
    public String info() {
        return "信息为 name= " + name + " age= " + age + " 薪水= " + salary;
    }
}

4. 封装与构造器

将构造器与set xxx 结合

五、继承（重点）

1. 为什么需要继承

观察以下两个代码，发现大学生和小学生考试两个类的很多属性都是相同的

解决方法：用继承解决代码复用性

2. 继承原理图

• 继承基本介绍和示意图
  • 介绍：继承可以解决代码复用,让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中 抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来 声明继承父类即可。
• 示意图：
  
• 继承的基本语法
  class 子类 extends 父类
  • 子类自动拥有父类的属性和方法

3. 快速入门

使用之前的案例，改进

4. 继承的优点

• 代码的复用性提高了
• 代码的扩展性和维护性提高了

5. 使用细节

• 细节1：

  • 子类继承了所有的属性和方法，（通过debug查看）
    
  • 非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问
    
  • 要通过父类提供公共的方法去访问
    

• 细节2：子类必须调用父类的构造器， 完成父类的初始化
  

  • 默认创建super()， 调用了父类的构造器，父类先被调用
    

• 细节3：

  • 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
    
  • 如果父类没有提供无参构造器，
    
  • 则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
    在子类的每个构造器中指定父类的构造器
    

• 细节4：如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
  

• 细节5：super在使用时，需要放在构造器的第一行

• 细节6：super() this() 都只能放在构造器的第一行，因此两个方法不能共存在一个构造器

• 细节7：java 所有类都是 Object 类的子类 CTRL + H 查看
  

• 细节8：父类构造器的调用不限于直接父类 将一直往上追溯直到 Object 类(顶级父类)

• 细节9：子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。
  思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】

• 细节10：不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

6. 继承的本质（重要）

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son(); //内存的布局 如上图
        ?-> 这时请大家注意，要按照查找关系来返回信息
        // (1) 首先看子类是否有该属性
        // (2) 如果子类有这个属性，并且可以访问，则返回信息
        // (3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
        // (4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object...
        System.out.println(son.name); //返回 儿子
        System.out.println(son.age); //返回 39
        System.out.println(son.hobby); //返回 旅游
    }
}
class GrandPa {
    String name = "爷爷";
    String hobby = "旅游";
}
class Father extends GrandPa {
    String name = "爸爸";
    int age = 39;
}
class Son extends Father {
    String name = "儿子";
}

总结

前面我们用sublime Text记事本学习了面向对象初级的内容，从这一章节开始，我们正式使用idea集成开发工具，学习和锻炼更为复杂的编程能力，同时也是对面向对象内容的更深度学习，包括包、封装、继承、重写、多态、转型、断点调试等内容。

受篇幅限制，本篇文章是韩顺平老师课程P264-P296（第8章：面向对象编程中级）上半部分重点内容的详细总结。

1. IDEA常用快捷键与模板
2. 包的使用与规范
3. 访问修饰符
4. 封装（重点）
5. 继承（重点）