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 ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

主要作用如下：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

内部类的方法可以直接访问外部类的所有数据，包括私有的数据

内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

内部类可分为以下几种：

成员内部类

静态内部类

方法内部类

匿名内部类

成员内部类
格式样例：
```
//外部类
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类中的方法，适合所有子类

toString();

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

可以通过重写toString()方法表示出对象的属性。
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();