(Eclipse快捷键; 包；权限修饰符；内部类；抽象类；接口概念和定义）Java零基础学习笔记 Day09

一，Eclipse进阶

（一）内容辅助键           

• alt / ：在想不起来代码的时候，可以使用这个按键来做代码的自动生成

• 应用：

1. main 配合 alt / ：生成主方法
2. syso 配合 alt / ：生成一个输出语句
3. Ctrl + 1 ：补全代码

• ​ 创建对象，可以使用内容辅助键，补全类名、构造方法，给变量起名字
• 遍历数组，for 配合 atl / ：遍历最近的数组

（二）Eclipse的常用的快捷键

       1、ctrl + n：新建工程、包、类和文件等内容

       2、Ctrl + shift + f：格式化代码

       3、Ctrl + shift + o：自动导包、删除没有用的包

       4、Ctrl + /：单行注释，取消单行注释

       5、Ctrl + shift + / ：多行注释

       6、Ctrl + shift + \ ：取消多行注释

       7、Alt + ↑：向上移动一行

       8、Alt + ↓：向下移动一行

       9、Ctrl + alt + ↑：向上复制一行

      10、Ctrl + alt + ↓ ：向下复制一行

      11、Ctrl + d：删除一整行

      12、Alt + shift + r：整体修改某个标识符名称

      13、F2：可以修改文件名称，并且将所有关联的位置一起修改

（三）快速生成一个自定义类的快捷键

      1、成员变量需要自己手动定义

      2、Alt + shift + s：

     C：生成空参构造
     O：生成有参构造
     R：生成getset方法，配合alt + a、alt + r

二，包

• 概述：存放并分类管理代码文件的特殊文件夹。

1. 包可以被编译器识别，其他普通文件夹不能被识别。
2. ​在开发工具中包默认在src的包下 ，src提供给编译器识别包

• 作用：分类管理代码
• 命名：公司域名倒写，名称全部小写，包和包之间使用 . 隔开
• 特点：

1. ​全部单词小写
2. ​ 唯一
3. ​ 不同的包中可以出现相同的名称的类、接口等资源

• 声明：

1. ​ 使用关键字 package 进行声明
2. ​ 格式：package 包的具体路径; 比如：package com.ujiuye.demo;

• 导包：

1. ​ 使用关键字 import +具体包路径 比如：import java.util.Scanner;
2. 运行：加载包当中相关的资源，通过导包的路径找到对应的资源。

 

三，权限修饰符

• 概述：修饰相关内容，使该内容的访问范围。在一定的范围我们可以访问使用，出了这个范围就不能访问
• 分类：

1. private：私有的 只在本类中可以使用 【常用的 封装属性】
2. 默认的：什么都不写 在本类可以使用，在同一个包下可以使用
3. protected：受保护的 在本类可以使用；在同一个包下也可以使用；不在同一个包下可以继承但不能被使用
4. public：公开的 没有范围限制 【最常用的】

代码示例

package com.ujiuye.demo;
public class Demo01 {
    private int a = 10;//私有的
     int b = 20;//默认的
    protected int c = 30;//受保护的
    public int d = 40;//公开的
    //在本类中使用这些资源
    public void show () {
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}
------------------------------------------------------------
package com.ujiuye.demo;
public class Test {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        //在测试类中使用四个变量
        //System.out.println(demo01.a);私有的访问不了  出了本类这个范围但是在同一个包下
        System.out.println(demo01.b);
        System.out.println(demo01.c);
        System.out.println(demo01.d);
    }
}
=========================================================
package com.ujiuye.demo01;
import com.ujiuye.demo.Demo01;
public class Test {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        //在测试类中使用四个变量
        //System.out.println(demo01.a);//私有的访问不了  出了本类这个范围但是在同一个包下
        //System.out.println(demo01.b);//默认的访问权限同包下，出了包的范围到其他包下访问不了
        //System.out.println(demo01.c);//受保护的访问权限同包下可访问，出了包的范围到其他包下可继承不能访问
        System.out.println(demo01.d);
        System.out.println("===============");
        //既然继承了使用子类对象访问这些属性
        Demo demo = new Demo();
        //还是直接访问 访问不了 子类还是在另外一个包中超出范围
        /*System.out.println(demo.a);
        System.out.println(demo.b);
        System.out.println(demo.c)*/;
        System.out.println(demo.d);
        demo.print();
    }
}
------------------------------------------------------------------
package com.ujiuye.demo01;
import com.ujiuye.demo.Demo01;
public class Demo extends Demo01{
    public void print() {
        //System.out.println(super.a);//私有的范围就是本类，这里其他包下访问不了 不能被继承
        //System.out.println(super.b);//默认的范围是本包，这里其他包下访问不了 不能被继承
        System.out.println(super.c);//受保护的范围是本包课访问，出包可继承
        System.out.println(super.d);
    }
}

​

四，内部类

• 概述：定义在一个类中的类叫做内部类。他类消失了一些类本身有的功能。
• 分类：

         1. 从位置划分：

​                 1.1. 成员位置：

​                      1.1.1，普通成员内部类

​                      1.1.2，私有成员内部类

​                      1.1.3，静态成员内部类

​                 1.2. 成员方法内部：

​                      1.2.1，局部内部类

         2. 从表示形式上划分：

​                 2.1. 有名的内部类：位置划分的内部类都属于有名的内部类

​                 2.2. 没有名字的内部类：匿名内部类【多态】

• 普通成员内部类

• 位置：类中的成员属性位置使用类的定义格式在定义一个类
• 定义格式：和类的格式是一样的:    class 内部类的名称 {书写内部类的内容}
• ​理解：我们可以把整个内部类看成是一个整体，整体看成外部类的一个特殊的属性，
• ​ 访问的时候：使用外部类的对象.内部类的对象
• 成员内部类的内容说明：【内部类丧失一些类功能】

1. ​ 不能定义静态的资源
2. ​ 可以使用外部类的所有资源
3. ​ 外部类不能直接使用内部类的资源，要想使用必须先创建内部类对象

• 内部类资源使用：

1. ​ 外部类中：在外部类的方法中创建内部类的对象，使用对象访问内部类的资源
2. ​ 外部类外：首先创建外部类的对象，调用内部类的对象 【创建出来】
3. ​ 格式：成员内部类名字 内部类对象名 = new 外部类名（）.new内部类类名（）

代码

package com.ujiuye.demo;
public class Outer01 {
    int a = 10;
    static  int b = 20;
    int d = 200;
    //成员内部类
     class inner{
        int a =100;
        //static int c = 30; 成员内部类不允许定义静态资源
         int c = 30;
        public void show () {  // 内部类可以访问所有的资源
            System.out.println(a); //100 变量的就近原则
            System.out.println(b); //20
            System.out.println(c); //30
            System.out.println(d); //200
            print();
        }
    }
     //外部类中使用内部类的资源必须创建内部类的对象
     public void print () {
         System.out.println(a);//就近原则访问自己的a 10 不是inner里面的a
        // System.out.println(c);//c是inner里面的c 报错 访问不了
         inner inner = new inner();
         System.out.println(inner.c);
         System.out.println("我是外部类的方法");
     }
}  
================================================================  
package com.ujiuye.demo;
import com.ujiuye.demo.Outer01.inner;
//测试类
public class Outer01_test {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.print();
        //直接使用成员内部类的资源【首先要进入外部类，再进入内部类】
        inner inner = new Outer01().new inner();
        System.out.println(inner.a);
        System.out.println(inner.c);
        inner.show();
    }
}

注意：内部类访问外部类的同名变量：固定格式：外部类名.this.变量名

• 私有成员内部类

• 位置：定义在成员位置上【类中方法外】被private修饰的成员内部类；

​                  访问权限【范围就变小了】，只能在本类【外部类】中使用

• 特征：普通的成员内部类被 private 关键字修饰
• 定义格式：private class 名称 {内部类的内容}
• 内容的说明：

1. 不能存在静态的资源
2. 他可以使用外部类的所有资源

• 使用：只能被外部类使用，出了外部类其他类使用不了。
• 外部类内：

1. ​ 在外部类中定义方法，方法中创建私有内部类的对象，用对象去调用资源
2. 如果外部类的外面也要使用内部类的资源怎么办？
3. ​ 在外部类中定义方法，方法中创建私有内部类的对象，用对象去调用资源
4. 外面的类创建外部类的对象调用外部类的这个方法间接的访问内部类的资源

代码

package com.ujiuye.demo;
public class Outer02 {
    int a = 10;
    static int c = 20 ;
    //私有成员内部类
    private class Inner{
        /*static*/ int d= 30;
        public /*static*/ void show() {
            //可以使用内部及外部类的资源
            System.out.println(a);
            System.out.println(c);
            System.out.println(d);
        }
    }
    public void useInner() {
        //创建内部类的对象
        Inner inner = new Inner();
        //使用对象访问对应的资源
        System.out.println(inner.d);
        inner.show();
    }

//提供一个外接访问内部类的方法
    public Inner get () {
        Inner inner = new Inner();
         /*System.out.println(inner.d);
        inner.show();*/
        return inner;
    }
}
====================================================
//测试类
package com.ujiuye.demo;
public class Outer02_Test {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.useInner();
        //new  Outer02().new Inner();不行，因为内部类私有化 出了类不能被访问  只能提供对外唯一访问方式
        //Inner inner = outer02.get(); 报错 Inner是Outer02的私有内部类  外接无权访问这个类  找不到这个类
    }
}

• 静态成员内部类

• 位置：类的成员位置【类中方法外】
• 特征：使用static 修饰的普同成员内部类
• 定义格式：static class 名称 { 内部类的内容​ }
• 访问说明：

1. ​静态内部类可以访问外部类的所有的静态资源【遵守static的使用元素原则】
2. 可以有自己的静态资源【比成员内部类好的地方】
3. 创建对象方式：【使用】

​           3.1在外部类的内部： new 内部类名（）；

          ​ 3.2在外部类的外部：new 外部类名. 内部类名（）

代码

package com.ujiuye.demo;
public class Outer03 {
    int a = 10 ;
    static int b= 20;
    //静态成员内部类
     static class Inner{
        //内容
        int  c = 30;
        static int d = 40;
        //使用外部类的资源
        public void show() {
            //System.out.println(a);a在外部类中不是静态资源
            System.out.println(b);
            //使用自己的资源
            System.out.println(c);
            System.out.println(d);
        }
    }
    //静态内部类的使用 外部类的内部
    public void userInner() {
        //创建内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.c);
        System.out.println(inner.d);
        inner.show();
    }
}
===========================================================
//测试类
package com.ujiuye.demo;
import com.ujiuye.demo.Outer03.Inner;
public class Outer03_Test {
    public static void main(String[] args) {
        //在外部类的外面直接的访问静态内部类的资源
        Inner inner = new Outer03.Inner();
        System.out.println(inner.c);
        System.out.println(inner.d);
        inner.show();
    }
}

• 局部内部类

• 位置：定义在方法的方法体中
• ​ 这个类属于方法，可以看做是方法局部的元素；
• ​ 外部类不能直接访问局部内部类的元素；只能通过所在方法调用来使用，但是局部内部类可以使用外部类中的资源。
• 说明：

1. 局部内部类中的成员访问时根据所在的方法不同而不同的

​           1.1 在静态方法中：

​                他只能访问外部类中的静态变量。

​                局部内部类中能出现静态资源？可以

​           1.2 在普通方法中：

​                他可以访问外部类中所有的资源

       2.  内部类可以访问所在方法中的变量（局部变量）？可以的。

       3.  出了局部内部类所在的方法范围外，无法访问局部内部类的内容的。

​            如何解决该问题？ 在局部内部类所在的方法中创建内部类对象使用对象访问里面相关资源

代码示例

package com.ujiuye.demo;
public class Outer04 {
    int a = 10;
    static  int b =20;
    public void  print() {
        //局部内部类
        class Inner{
            int c = 30;
            //static int d = 40 ;不允许出现静态的资源
            public void show() {
                //访问外部类的资源
                System.out.println(a);
                System.out.println(b);
            }
        }
        //局部内部类的使用【在所在的方法中创建局部内部类的对象，使用对象调用对应的资源】
        Inner inner = new Inner();
        System.out.println(inner.c);
        inner.show();
    }

    //外部类的方法想要使用内部类的资源
    public void run() {
        //System.out.println(c);
        //new Inner()
        //调用局部内部类所在的方法从而达到访问内部类资源的效果
        print();
    }

}

五，抽象类

• 抽象方法：

1. ​ 抽象方法：被关键字abstract修饰的并且没有方法体的方法
2. ​ 抽象：想象出来的，虚幻的，没有实体的
3. ​ 作用：对外声明行为。【广告】
4. ​ 特点：对外只声明自己的功能，不会去做这个功能
5. ​ 好处：方法的功能扩展性强
6. ​ 格式：修饰符 abstract 返回值类型 方法名（形式参数）；

​                   比如：public abstract GrilFriend getGrilFriend（int money）；

​                   注意：抽象方法必须存在于抽象类和接口中，要想具体化必须要被重写

• 抽象类

1. 概述：被abstract修饰的类就叫做抽象类

• 抽象类的内容：

1. 成员变量：描述事物属性的。和普通的变量时一样。
2. 构造方法：和普通类的构造一样的【写法样式一样】

​                         作用不一样了：不能创建对象了，给子类对象调用使用的抽象类有构造方法吗？

​                         有，但是不能创建自己对象，是给子类使用的。子类创建对象的时候优先加载父类的构造方法

      3.  成员方法

​             普通方法：正常的进行定义

​             抽象方法： 抽象类增加的一个方法【没有具体的执行语句】

​      4.  抽象类和抽象方法的关系：抽象类中不一定有抽象方法；有抽象方法的类一定是抽象类

      5.  特点：

             5.1  一定被abstract修饰

             5.2  有构造但是不能创建自己的对象

             5.3  抽象方法可有可无

             5.4  有抽象方法类必须是抽象类

             5.5  抽象方法必须要被子类重写

       6.  使用场景：抽象类用作于父类，抽取子类中的一些共性行为，共性行为的动作不一样。

比如：

1. ​ 学生有工作的行为：学习
2. ​ 老师有工作的行为：讲课
3. ​ 把这个工作的行为提取父类中

代码示例： 创建抽象类

package com.ujiuye.demo;
//父类
public abstract class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //共性的行为 工作 抽象方法
    public abstract void work();
}
=======================================================
//创建教师子类
package com.ujiuye.demo;
public class Teacher extends Person{
    @Override
    public void work() {
        System.out.println("好好讲课，善待学员");
    }
}
========================================================
//创建学生子类
package com.ujiuye.demo;
public class Student extends Person{
    @Override
    public void work() {
        System.out.println("好好学习，天天向上");
    }
}
===========================================================
//测试类
package com.ujiuye.demo;
public class Person_Test {
    public static void main(String[] args) {
        Student student = new  Student();
        Teacher teacher = new  Teacher();
        student.work();
        teacher.work();
    }
}

注意：抽象类有多个抽象方法，子类必须全部重写

 

练习

1. 程序员类：属性（姓名、工号、工资、奖金），行为（工作：软件开发）
2. 测试工程师：属性（姓名、工号、工资），行为（工作：软件测试）
3. 项目经理类：属性（姓名、工号、工资、奖金），行为（工作：控制进度）

• 分析：

1. ​ 有共同相似的内容：姓名 工号 工资 行为（工作）可以向上抽取成为一个类 抽象类
2. ​ 分别定义程序员类 测试工程师类 项目经理类继承抽象类 重写行为

代码

//抽象类[父类]
package com.ujiuye.demo;
public abstract class Employee {
    private String name;
    private String id;
    private double salary;
    //共性行为 抽象方法
    public abstract void work(); 
    public Employee(String name, String id, double salary) {
        super();
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    public Employee() {
        super();
        
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    
}
==============================================
//程序员类[子类]
package com.ujiuye.demo;
public class Coder extends Employee{
    private double bonus;
    //重写抽象方法
    @Override
    public void work() {
        System.out.println("软件开发");
    }
    public Coder(String name, String id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }
    public Coder() {
        super();
        
    }
    public Coder(String name, String id, double salary) {
        super(name, id, salary);
        
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}
===============================================
//测试工程师[子类]
package com.ujiuye.demo;
public class Tester extends Employee{
     //重写抽象方法
    @Override
    public void work() {
        System.out.println("软件测试");
    }

    public Tester() {
        super(); 
    }

    public Tester(String name, String id, double salary) {
        super(name, id, salary);
    }
}
============================================
//项目经理类[子类]
package com.ujiuye.demo;
public class Manager extends Employee{
    private double bonus;
     //重写抽象方法
    @Override
    public void work() {
        System.out.println("项目的控制");
    }
    public Manager(String name, String id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }
    public Manager() {
        super(); 
    }
    public Manager(String name, String id, double salary) {
        super(name, id, salary);  
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}
================================================
//测试类
package com.ujiuye.demo;
public class Employee_Test {
    public static void main(String[] args) {
        Coder coder = new Coder();
        coder.work();
        Manager manager = new Manager();
        manager.work();
        Tester tester = new Tester();
        tester.work();
    }
}

七，接口

• 概念：

1. ​ 接口是引用数据类型的一种，我把类可以看做是事物属性和行为以及构造器的集合体，接口就可以看做是不同类型的事物的相似行为的集合体。
2. 举例：人可以走路 动物可以走路 机器人也可以走路，走路相似的行为，走路的方式不一样，就可以把不同事物的走路行为声明提取出来，放到一个集合中，由于方法体不一样就不写，把行为变为抽象的；这个集合命名为接口。

• 接口：就是行为规范的设定。就是规则集合，接口就是准则。

​                  抽象类是对同一系列的事物的共性行为声明的提取，接口就是不同系列事物的共性行为声明提取

• 编译：参与编译，编译后也是.class文件【类和接口编译后都是字节码文件】
• 接口的使用：

1. 定义接口
2. 使用类来实现，并重写方法
3. 创建类对象调用重写后的方法

• 接口的定义：格式：修饰符 interface 接口名称 {接口内容}

• 解释：

  ​ interface：就是关键字 表示就是接口

  ​ 接口名称：自己命名。遵循见名知意、大驼峰格式

• ​ 内容：

1. ​ 属性：接口的属性只能是常量 或者被 final 修饰的变量
   
    注意：
   
   ​ 1.1、属性是默认被 public static final修饰的
   
   ​ 1.2、声明属性的时候必须给他赋值

2.  构造方法：接口没有构造方法，所以接口不可以创建对象

​      3.  行为：jdk1.8之前接口只有抽象方法;【抽象方法就是行为声明的表现形式】

代码示例

package com.ujiye.demo;
public interface InterfaceA {
    //接口内容
    //属性
    /*public static final*/ 
    int  a = 10;//默认被public static final 修饰
    public static final int b = 30 ;
    //行为
    public  abstract  void run();
}

• 接口和抽象类的区别：

  ​ 1、抽象类是对子类的共性行为声明的提取【子类要求是同一系列的类局限性小】

  ​ 2、接口是对不同系列的事物的共性行为声明的提取【就没有局限性】

  ​ 3、抽象类是被类继承的，接口只能被类实现