原视频来自慕课网

类和对象

类：访问修饰符 class 类名 { } //一般通过编译器自动创建

对象 :类名 对象名 = new 类名(); //占用内存

成员变量 和 局部变量

成员变量（全局变量）:对象应有的属性值

局部变量:临时保存数据

成员变量和局部变量同名时,局部变量有更高优先级

image

构造方法(构造函数):

访问修饰符 构造方法名(参数) {代码块}

可以通过无参和有参的构造方法创建类的对象

有参的构造方法可以给实例变量赋予初值

当没有构造方法时，系统会自动添加无参的构造方法,当有指定构造方法时，则不会自动添加,构造方法也可重载

静态成员

关键词 : static , 改类实例共用 ， static 可以修饰变量、方法和代码块。

栗子:static String className = "JAVA开发一班"; 调用 类名.className

static public void lover() {代码块} 调用 类名.lover()

静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。可以创建对象来访问静态成员，方法同理.

静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
举个栗子:

public class HelloWorld {
    String name; // 声明变量name
    String sex; // 声明变量sex
    static int age;// 声明静态变量age
    // 构造方法
    public HelloWorld() {
        System.out.println("通过构造方法初始化name");
        name = "tom";
    }
    // 初始化块
    {
        System.out.println("通过初始化块初始化sex");
        sex = "男";
    }
    // 静态初始化块
    static {
        System.out.println("通过静态初始化块初始化age");
        age = 20;
    }
    public void show() {
        System.out.println("姓名：" + name + "，性别：" + sex + "，年龄：" + age);
    }
    public static void main(String[] args) {
        // 创建对象
        HelloWorld hello = new HelloWorld();
        // 调用对象的show方法
        hello.show();
    }
}

通过静态初始化块初始化age
通过初始化块初始化sex
通过构造方法初始化name
姓名：tom，性别：男，年龄：20

通过运行可以看出,静态初始化总是先执行

封装

包:

//package  文件路径
import java.util.Arrays;
import java.util.*；//如果导入util下
所有类

访问修饰符:

this：关键词 在对象中相当于oc的self, 表示该类的实例对象

内部类

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

//外部类HelloWorld
public class HelloWorld{
    //外部类的私有属性name
    private String name = "imooc";
    //外部类的成员属性
    int age = 20;
    //成员内部类Inner
    public class Inner {
        String name = "爱慕课";
        //内部类中的方法
        public void show() { 
            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();
    }
}

静态内部类

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

方法内部类

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

继承

有个好爸爸，少奋斗几十年。只有一个亲爸爸。hahaha
class 子类 extends 父类 {}
重写父类方法:和父类方法一样即可,最好加个@Override,编译器会查看父类是否有此方法
创建子类对象会先执行父类属性初始化 -> 构造方法再执行子类属性初始化 -> 构造方法

final

final可修饰类，属性，方法，变量
修饰类：则不允许继承
修饰方法：不允许重写
修饰变量: 变成常量了（好惨啊,不能72变了）
修饰属性：初始化属性必须有值或在构造函数中赋值

super

代表父类对象（不是爸爸的对象，是爸爸的对象。。。算了说不清楚）
子类构造过程必须先调用父类构造方法
如果显示的调用父类构造方法，则必须在第一行。
不显示，则编译器隐式调用;
如果父类没有无参构造方法，就必须显示调用.

Object 类(祖宗来了)

Object 是所有类的父类。如果没有 写 extends Object，那Object就是"祖宗"。
toString()
如果没有重写，则会打印出对象的哈希码（就像人的身份证）
重写后打印重写内容；
equals()
比较对象是否引用同一个内存地址
一般情况需要比较其值是否相同，如果这样就要重写此方法

多态

对象的多种形态
1.引用多态:
父类的引用可以指向子类的对象
父类的引用可以指向本类的对象
2.方法多态:
创建本类对象时，调用的是本类的方法
创建子类对象时，调用的是子类重写的方法或继承的方法
引用类型转换
小类型到大类型:向上类型转换(隐式/自动转换)
大类型到小类型:向下类型转换(强制类型转换)
instanceof运算符,避免类型转换的安全问题
举个栗子:if (对象 instanceof 类) {真}else {假}

抽象类

关键字: abstract
约束子类必须实现哪些，但如何实现
抽象类可以只声明抽象方法，将实现交给子类.
大栗子:

public abstract class Shape {
    public abstract void perimeter();
    public abstract void area();
}

package shape;
public class Rectangle extends Shape {
    double length;
    double width;
    public Rectangle(double length,double width){
        this.length = length;
        this.width = width;
    }
    @Override
    public void perimeter() {
        System.out.println("长方形周长:" + 2 * (length + width));
    };
    @Override
    public void area() {
        System.out.println("长方形面积:" + length * width);
    };
}

package shape;
public class Cricle extends Shape {
    double radius;
    public Cricle(double radius){
        this.radius = radius;
    }
    @Override
    public void perimeter() {
        System.out.println("圆周长:" + 2 * 3.14 * radius);
    };
    @Override
    public void area() {
        System.out.println("圆面积:" + 3.14 * radius * radius);
    };
}

主函数调用:

        Shape cricle = new Cricle(3);
        cricle.perimeter();
        cricle.area();
        Shape rectangle = new Rectangle(3,2);
        rectangle.perimeter();
        rectangle.area();

接口

接口定义了某一批类要遵守的规范,他规定这些类必须提供某些方法.
关键词 :interface
访问修饰符 interface 接口名[extends 父接口1，父接口2...]{零到多个常量定义,零到多个抽象方法定义}
接口中的常量
public static final 系统会自动添加
接口中的方法
public abstract 系统自动添加
实现接口用implements ，java只能有一个父类，可以通过多个接口来补充。
继承父类实现接口:
修饰符 class extends 父类 implements 接口1，接口2... {如果继承了抽象类，需要实现继承的抽象方法；要实现接口的抽象方法。}
又是一个大栗子:

public interface PlayGame {
    public void doPlayGame();
}

public class Psp implements PlayGame {
    @Override
    public void doPlayGame() {
        System.out.println("psp玩游戏");
    }
}

public class SmartPhone implements PlayGame {
    @Override
    public void doPlayGame() {
        System.out.println("智能手机玩游戏");
    }
}

主函数调用:

        PlayGame psp = new Psp();
        psp.doPlayGame();
        PlayGame smartPhone = new SmartPhone();
        smartPhone.doPlayGame();
        PlayGame pc = new PlayGame() {
        //使用匿名内部类的方式实现接口
            @Override
            public void doPlayGame() {
                System.out.println("电脑玩游戏");
            }
        };
        pc.doPlayGame();
        new PlayGame() {
        //又一个匿名内部类
            @Override
            public void doPlayGame() {
                System.out.println("不知道什么东西玩游戏");
            }
        }.doPlayGame();