Java知识点速记（二）

注：本文为本人在慕课网：Java入门第二季学习后整理的学习笔记，方便自己查阅。笔记资料均来自慕课网：Java入门第二季https://www.imooc.com/learn/124，如侵删。

一.类和对象

1.类

类的组成：属性（就是特征）和方法（就是能做什么事情）
语法：public class 类名{
定义属性部分（即定义成员变量）
定义方法部分
}

2.对象

2.1创建对象

语法：类名 对象名=new 类名();

2.2使用对象

2.2.1引用对象属性

语法：对象名.属性名
通过对象名.属性名=值；可以为对象的属性赋值

2.2.2调用对象方法

语法：对象名.方法名();

3.成员变量和局部变量

0.作用域不同:
成员变量可在整个类（class）中使用;
局部变量只能在定义它的方法内使用。
1.初始值不同：
声明成员变量系统自动赋初值0；
声明局部变量系统不会自动为其赋初值，因此声明局部变量时要为局部变量赋初始值。
2.在一个方法中，不能有同名的局部变量；
在不同方法中，可以有同名的局部变量<——因为局部变量只能在定义它的方法内使用，因此不同方法中即使同名了也不相关。
3.成员变量和局部变量同名时，在方法内使用时，局部变量有更高的优先级

4.构造方法

语法：public 构造方法名（参数）{代码块}
功能：new+构造方法名（） 创建一个新的对象
定义：定义在Java类中的一个用来初始化对象的方法
特点：1.构造方法名等于类名，构造方法没有返回值，可以有参，也可以无参。2.当没有指定构造方法时，系统自动调用一个无参构造方法。3.当有指定构造方法是，无论指定了有参还是无参的构造方法，系统都不会再自动添加一个无参构造方法了4.构造方法的重载同一般方法的重载5.可以通过构造方法给对象赋一个合理的值

5.static 使用

5.1静态变量

语法：static 变量类型 变量名=值；
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问
使用 static 可以修饰变量、方法和代码块。
静态变量和非静态变量的差异：
1.调用的方法不同。静态变量可以通过类名调用也可以通过对象名调用，但是非静态变量只能通过对象名调用。
2.分配的内存空间不同和生命周期不同。类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被类的所有实例共享。每创建一个实例，java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中，其生命周期取决于实例的生命周期。

5.2静态方法

语法：访问修饰符 static 返回值类型 方法名（参数列表）{ 方法体 }
规则：
1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
静态方法与非静态方法的区别：
1.生命周期
静态方法随着类的出现而出现，非静态方法随着实例对象的出现而出现
2.调用
静态方法可以通过类名或对象名调用，非静态方法通过创建一个对象调用

5.3静态初始化块

语法：static{初始化代码块}
静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
实例：

运行结果：
通过输出结果可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。

二.封装

1.封装

封装就是在某一个类的属性前加上private，让其他类无法调用该类的属性进行随意地修改或赋值。但是其他类可以通过set和get的方法修改和得到该属性值。比如现在对类名为Telephone的某一个类封装把原来的double size 改为 private double size，创建getSize()和setSize(double size)方法。
当其他类调用该类的size属性时只能用新建一个该类对象，然后用set/get方法

Telephone tp=new Telephone();
//得到Telephone类的size属性
double size=tp.getSize();
//修改Telephone类的size属性
tp.setSize(3.14)；

2.this

1.this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 操作当前对象的方法
2.封装对象属性时，常用this关键字

public class Telephone{
private String screen;
private double size;
public double getSize(){
return size;}
public void setSize(double size)
//用this区分参数size和对象属性size，把参数size赋值给当前对象的size
this.size=size;}
}
...

3.包

3.1包的作用

1.管理Java文件
2.解决同名文件冲突。也就是说可以把不同的包中的同名文件区分开来。包就像计算机中的文件夹，即使不同文件夹中有同名文件，因为处在不同文件夹中路径不同，所以就把同名文件区分开了。计算机中的文件用“/”表示路径，包中用”.”表示路径，同一个包内的Java文件不能同名。

3.2定义一个包

package 包名
必须放在源程序的第一行！
例：package com.hello.Myclass;

3.3包的使用

1.可以通过import，在某个文件中使用其他包中的类
例：import com.hello.Myclass;（另Myclass是包hello下的一个Java文件）
2.包的命名规范是全小写字母拼写
3.使用时加载某个包下的所有Java文件import com.hello.*
加载某个包具体子包下的所有Java文件import com.hello.helloworld.*（另helloworld为建在包hello下的子包）

4.访问修饰符

5.内部类

5.1内部类基本概念

5.1.1定义

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

5.1.2作用

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

5.1.3种类

内部类可分为以下几种：成员内部类，静态内部类，方法内部类，匿名内部类。

5.2成员内部类

成员内部类，又称普通内部类。定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
规则：
1、 外部类是不能直接使用内部类的成员和方法，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。即：外部类.this.属性名

//外部类HelloWorld
public class HelloWorld{ 
    //外部类的私有属性name
    private String name = "imooc";
    //外部类的成员属性
    int age = 20;

    //成员内部类Inner,类Inner在类HelloWorld的内部
    public class Inner {
        //内部类中的属性，此属性和外部类的私有属性name重名
        String name = "爱慕课";
        //内部类中的方法
        public void show() { 
            //重名时：外部类.this.属性名
            System.out.println("外部类中的name：" + HelloWorld.this.name);         
            System.out.println("内部类中的name：" +name);
            System.out.println("外部类中的age：" + age);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        //创建外部类的对象
        HelloWorld o = new HelloWorld (); 
        //创建内部类的对象
        Inner inn = o.new Inner()  ;
        //调用内部类对象的show方法
        inn.show();
    }
}

5.3静态内部类

静态内部类是 static 修饰的内部类（即：访问修饰符 static class 内部类名(){}），这种内部类的特点是：
1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2、 如果外部类的静态成员与内部类的成员名称相同，可通过外部类.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

//外部类
public class HelloWorld {
    // 外部类中的静态变量score
    private static int score = 84;
    // 用static创建静态内部类
    public static class SInner {
        // 内部类中的变量score
        int score = 91;
        //内部类中的方法
        public void show() {
            System.out.println("访问外部类中的score：" +HelloWorld.score);
            System.out.println("访问内部类中的score：" + score);
        }
    }

    // 测试静态内部类
    public static void main(String[] args) {
        // 直接创建内部类的对象
        SInner si=new  SInner(); 
        // 调用show方法
        si.show();
    }
}

运行结果：
访问外部类中的score：84
访问内部类中的score：91

5.4方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。由于方法内部类不能在其所在的外部类方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

//外部类
public class HelloWorld {

    private String name = "爱慕课";

    // 外部类中的show方法
    public void show() { 
        // 定义方法内部类，无访问控制符和 static 修饰符
        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();
    }
}

三.继承

1.继承

语法：public 子类 extends 父类{}
子类会继承父类所有的属性和方法，子类只能继承一个父类（就像一个人只能有一个亲生父亲）

2.方法的重写

3.继承的初始化顺序

也就是说，当new一个子类对象出来时，会先初始化父类对象（先属性后方法）再初始化子类对象（先属性后方法）。

4.final的使用

5.super的使用

6.Object类

object类，是所有类的父类，一般没有任何extends关键字时都默认是object子类；object类，所有的方法适用所有的子类。

6.1 toString()方法

1.如果在执行程序中直接操作输出一个类的对象，则结果会输出一个哈希码的值
（哈希码（code)是通过哈希码方法生成的字符串，来区别对象地址，如果只针对对象，程序已经直接隐藏了toString方法 ）
2.如果在执行程序中需要得到一个类的属性，需要在对应类里进行重写toString()方法，执行程序无需改动

6.2 equals()方法

用在判断对象相等
首先判断对象相等有两种含义：1，对象是其本身。（比如说你在公交车上丢了手机，回去找的时候发现有人手上拿着和你的手机一模一样的手机，你就想这跟手机是不是你丢的手机）2.两个对象的相等。两个对象的属性方法一模一样。（比如两根同品牌同型号同内存等等各方面一模一样的手机）
equals（）默认判断两个对象的引用是否指向同一个地址，就是第1种情况，因为不同的对象会分配不同的地址。如果要判断第2种情况，就要重写equals（）方法

四.多态

1.多态

多态即对象的多种形态，有继承才能使用多态。
1.引用多态
父类的引用可以指向本类的对象；
父类的引用可以指向子类的对象。

//父类的引用就是obj1 和obj2，本类对象就是new Animal（）；子类对象就是new Dog（）；
Animal obj1=new Animal();
Animal obj2=new Dog();

2.方法多态
创建父类的本类对象时，调用的方法为本类的方法；
创建子类对象时，调用的方法为子类重写的方法或者子类从父类继承来的方法。（创建子类对象调用方法具体过程是：当使用多态方式调用方法时，首先检查父类中是否有你调用的那个方法，如果没有则编译错误；如果有，再去调用子类的 该方法。）

2.多态的引用类型转换

前面多态部分讲到引用多态,就又涉及到引用类型转换的问题。同数据类型转换一样，多态引用类型的转换也分为自动类型转换和强制类型转换。
如图中小类型（常常为子类）就好比茶杯，大类型（常常为父类）就好比茶壶，把茶杯里全部的水倒进茶壶，不会有溢出，系统会自动转换，就是自动类型转换，但是把茶壶里全部的水倒进茶杯就可能有溢出的风险，系统自然不会主动做这样的事，这时候就需要强制类型转换。

//Animal是父类，Dog是继承Animal的子类
Dog dog=new Dog();//创建一个子类对象
Animal animal=dog;//声明一个新对象animal对象：把dog对象赋给animal，为向上类型转换，dog自动转换为Animal
Dog dog2=(Dog)animal;//创建第二个子类对象，把刚刚的animal对象赋给dog，此时为向下转换，即强制类型转换为Dog类

为什么需要引用类型的强制转换呢？
当子类有的方法，父类中没有的时候，这时候就需要将父类转换为子类，这样就可以使用子类里有父类里没有的方法了。
**3.**instanceof运算符，来解决引用类型的对象，避免类型转换的安全性问题

if(animal instanceof Dog){           
        Dog dog3=(Dog)animal;}
        else {           
        System.out.println("无法进行类型转换");}

3.抽象类

抽象类相当于一个父类模板，只定义方法定义的方法没有方法块。

pubilc abstract class Animal{
public abstract void eat();
public abstract void sleep();
...}

4.接口

4.1接口定义

接口中属性和方法的定义

4.2匿名内部类实现接口

附：&参考文章：1.Java基础——成员变量、局部变量和静态变量的区别
https://blog.csdn.net/haovip123/article/details/43883109
2,静态方法与非静态方法的区别https://www.cnblogs.com/OldZhao/p/5034888.html