Java学习笔记--基础概念

1、封装

概念：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

好处：
a、只能通过规定的方法访问数据。
b、隐藏类的实例方法，便于修改和实现。

2、继承

• 语法规则：

  class 子类 extends 父类 {
  
  }
  

• 概念： 类与类之间的一种关系。Java中的继承是单继承。

• 好处：
  a、子类拥有父类的所有属性和方法(private修饰的除外)。
  b、实现代码复用。

• 初始化顺序：
  a、初始化父类再初始化子类
  b、先执行初始化对象中的属性，再执行构造方法中的初始化。

• final关键字
  使用final关键字具有“最终的”含义。
  可以修饰类、方法、属性、变量。

  • 修饰类，则该类不允许被继承。
  • 修饰方法，则该方法不允许被覆盖（重写）。
  • 修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值），或者在构造方法中赋值（但只能选其一）。
  • 修饰变量，则该变量的值只能被赋值一次，即为常量。

• super的应用

  • 调用父类属性。eg：super.age;
  • 调用父类方法。eg：super.eat();
  • 子类的构造的过程中必须必须调用其父类的构造方法。

  a、如果子类的构造方法中没有显式调用父类的构造方法，则系统会默认调用父类的无参构造方法。
  b、如果显式的调用构造方法，必须放在在子类构造方法的第一行。
  c、如果子类构造方法中没有显式调用父类的构造方法，而父类中又没有无参的构造方法，则编译会报错

3、多态

• 引用多态
  父类的引用指向子类的对象。

• 方法多态
  父类的引用指向子类的对象，调用的方法为子类重写的方法或者继承的方法，注意：不能调用子类自有而父类中没有的方法。

• 引用类型转换
  通过instanceof运算符避免类型转换的安全性问题。

4、使用包管理Java中的类

• 1、包的作用：
  a、管理Java文件。
  b、解决同名文件冲突的问题。
• 2、定义包
  注意：必须放在Java程序的第一行
  包名间可以使用“.”号分隔开。eg：com.imooc.myclass
• 3、系统中的包
  java.(功能).(类)
  java.lang.(类) 包含java语言的基础类。
  java.util.(类) 包含java语言中各种工具类。
  java.io.(类) 包含输入、输出功能相关的类。
• 4、包的使用
  (1)、可以使用import关键字，在某个文件中使用其他文件中的类。
  eg：import com.imooc.music.MyClass
  (2)、java中，包的命名规范是全部小写字母拼音。
  (3)、使用的时候不但可以加载某个包下的所有文件，
  eg：import com.imooc.*
  也可以加载某个具体子包下的所有文件。
  eg：import com.imooc.music.*

5、Java中的访问修饰符

访问修饰符	本类	同包	子类	其它
private	true	false	false	false
默认	true	true	false	false
protected	true	true	true	false
public	true	true	true	true

6、Java中的this关键字

• 1、this关键字代表当前对象。
  this.属性：代表操作当前对象的属性。
  this.方法：代表调用当前对方的方法。
• 2、封装对象的属性的时候，经常使用到this关键字。

7、Java的内部类

概念：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

内部类可分为以下几种：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

• 成员内部类
  格式样例：

  //外部类
  public class HelloWorld(){
      private String name = "hello";
      //内部类
      public class Inner(){
          private String name = "world";
          public void show(){
              System.out.println("外部类中的name：" + HelloWorld.this.name);
              System.out.println("内部类中的name：" + name);
          }
      }
  
      public static void main(String[] args) {        
          HelloWorld hello = new HelloWorld();
          //内部类的初始化
          Inner inner = hello.new Inner();
          inner.show();
      }
  }
  

  注意：

  1、外部类是不能直接使用内部类的成员和方法的。(可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。)
  2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。eg：HelloWorld.this.name
  3、内部类可以使用任意访问修饰符，无论是对方法还是属性，都可以被外部类访问。内部类也可以直接访问外部类的任意属性或方法，包括私有数据。
  4、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
  5、编译上面的程序后，会发现产生了两个 .class 文件

• 静态内部类
  格式样例：

  //外部类
  public class HelloWorld(){
      private static String name = "hello";
      //内部类
      public static class SInner(){
          private String name = "world";
          public void show(){
              System.out.println("外部类中的name：" + HelloWorld.name);
              System.out.println("内部类中的name：" + name);
          }
      }
  
      public static void main(String[] args) {        
          //内部类的初始化
          Inner inner = new Inner();
          inner.show();
      }
  }
  

  静态内部类的特点是：

  1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。
  2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员。
  3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类 对象名= new 内部类()。

• 方法内部类
  概念：方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

  格式样例：

  //外部类
  public class HelloWorld {
  
      private String name = "英语";
      
      // 外部类中的show方法
      public void show() { 
          // 定义方法内部类
          class MInner {
              int score = 83;
              public int getScore() {
              return score + 10;
              }
          }
          
          // 创建方法内部类的对象
          MInner mi = new MInner();
          
          // 调用内部类的方法
          int newScore = mi.getScore();
          
          System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
      }
  
      // 测试方法内部类
      public static void main(String[] args) {
      
          // 创建外部类的对象
          HelloWorld mo = new HelloWorld();
      
          // 调用外部类的方法
          mo.show();
      }
  }
  

  注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

• 匿名内部类
  就是没有名字的内部类，
  多用于关注实现而不关注实现类的名称

8、Object类

概念：Object类是所有类的父类，如果一个类没有使用extends关键字明确标示继承另一个类，那么这个类默认继承Object类。

Object类中的方法，适合所有子类

1. toString();

   在Object类里面定义toString()方法的时候返回对象的哈希code码（对象地址字符串）。

   可以通过重写toString()方法表示出对象的属性。

2. equals();

   比较的是对象的引用是否指向同一块内存地址。

9、抽象类

• 语法定义
  抽象类前使用abstract关键字修饰，则该类为抽象类。
  eg:

  public abstract class Animal {
      public abstract void grow();
  }
  

• 应用场景

  a. 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但是无法准确知道这些子类如何实现这些方法。
  b. 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计上的随意性。

• 作用
  限制规定子类必须实现某些方法，但不关注实现细节。

• 使用规则

  a. abstract定义抽象类。
  b. abstract定义抽象方法，只有声明，不需要实现。
  c. 包含抽象方法的类是抽象类。
  d. 抽象类中可以包含普通的方法，也可以没有抽象方法。
  e. 抽象类不能直接创建，可以定义引用变量。

注意：抽象方法没有方法体，以分号结束

10、接口

• 概念
  类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

• 定义
  和类定义不同，定义接口不在使用class关键字，而是使用interface关键字。

• 基本语法

  [修饰符] interface 接口名 [extends 父接口1,父接口2...] {
      0个到多个常量定义...
      0个到多个抽象方法的定义...
  }
  

  注意：接口就是用来被继承、被实现的，修饰符一般建议使用public，不能使用private和protected修饰接口

• 接口中的常量
  接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上。

• 接口中的方法
  接口中的方法只能是抽象方法，在使用时，即使定义时不添加public abstract修饰符，系统也会自动加上。

• 使用接口
  一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。
  eg：

  [修饰符] class 类名 extends 父类 implements 接口1,接口2...
  {
      类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
      public void method(){
          //类的实现
      }
  }
  
  Interface i = new 实现类();
  i.method();
  
  

  注意：如果要继承父类，继承父类必须在实现接口之前

• 配合匿名内部类使用

  Interface i = new Interface(){
      public void method(){
          //类的实现
      }
  }
  i.method();