Java类和对象（继承、多态、封装）

概念

面向对象编程：类和对象
把一系列具有相同属性和行为的物体归为一个类，如：
class 人{
属性，行为
}

继承

方法重载

继承：子类对象具有父类的实例域和方法

类与类关系
组合关系： has a
继承： is a

new出来的对象的属性以及方法:
父类继承下来的
自己增加的

同包路径：默认权限
跨包路径：子类访问父类，父类参数用protected修饰

面试题：Java继承为什么只能单继承不能多继承？
会出现棱形继承

重写

在方法前加一个@Override,重写子类继承父类的方法

面试题： 方法重载和重写的区别？
方法重载：在一个类，函数名相同，参数列表不同
重写：在父子类中，子类需要重写父类的方法（函数名以及参数列表相同），子类访问权限必须大于等于父类访问权限
public和protected：相同包路径下<=>默认权限，不同包路径下子类可以访问父类protected修饰符

重写的实现原理？
子类的实现将父类的方法进行地址覆盖

public class People1 {
    private String name;
    private int age;
    public People1(String name, int age){
        this.name = name;
        this.age = age;
    }
}

public class Student extends People1 {
    private int score;
    public Student(String name,int age,int score){
        super(name,age); //继承父类的属性
        this.score = score;
    }
    @Override //重写equals方法
    public boolean equals(Object obj){
        if(this == obj){ //s1.equals(s1)
            return true;
        }
        if(obj instanceof Student) {
            Student student = (Student) obj; //相同数据类型才能进行强转比较
            return score == student.score;
        }
        return false;
    }
}

public class StudentText {
    public static void main(String[] args){
        Student student1 = new Student("zs",15,99);
        Student student2 = new Student("ls",15,95);
        System.out.println(student1.equals(student2));
    }
}

多态

多态的三个条件：继承，方法重写，向上造型（基类引用 引用 派生类的对象）

向上造型

People people = new Student();

people引用的是父类People的方法接口，但方法的实现是子类Student的实现方式

static 关键字

1.静态变量

与实例变量的区别
存储位置：实例变量存储在java堆， 一个对象对应一份实例变量
静态变量存储在方法区， 一个类对应一个静态变量

2.修饰方法
静态方法和实例方法的区别：实例用this，静态不能用this

3.类的初始化顺序（重点）：静态变量-> 静态块-> 实例变量 -> 实例块-> 构造

class InstanceTest{
    public InstanceTest() {
        System.out.println("实例变量");
    }
}
class StaticTest{
    public StaticTest() {
        System.out.println("静态变量");
    }
}
class MazeNode{
    private InstanceTest name = new InstanceTest();
    private static StaticTest count = new StaticTest();
    static {
        System.out.println("静态块");// 专门用来初始化静态变量
    }
    {
        System.out.println("实例块"); // 专门初始化实例变量
    }
    public MazeNode(){
        System.out.println("构造");
    }
}
public class JIngtai {
    public static void main(String[] args) {
        MazeNode mazeNode = new MazeNode();
    }
}

4.设计模式：单例模式：懒汉和饿汉单例模式

// 快加载单例模式（饿汉单例模式）
public class Singleton {
    private static Singleton instance = new Singleton();//一个类只被加载一次

    private Singleton(){
    }
    public static Singleton getInstance(){
        return instance;
    }
}
// 慢加载单例模式（懒汉单例模式）
class Singleton2 {
    private static Singleton2 instance;

    private Singleton2(){
    }
    public static Singleton2 getInstance(){
        if(instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}
class Test{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        Singleton s3 = Singleton.getInstance();
        System.out.println(s1 == s2);
        System.out.println(s2 == s3);
    }
}

5. final关键字 ->终极

private static final int INITSIZE  =10;

修饰常量
修饰的方法不能被重写
修饰的类不能被继承

封装

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

2.封装的实现步骤
（1）修改属性的可见性为 private;
（2）创建get和set方法（用于属性的读写），并在方法中加入属性控制语句。

3.访问修饰符
private：只能在本类使用
protected：本类、同包、子类使用
public：本类，同包，子类，其他中都可以使用

4、java中的this关键字
this关键字代表当前对象
this.属性：操作当前对象的属性
this.方法：调用当前对象的方法
封装对象的属性的时候，经常会使用this关键字

class Node<T>{
        protected T data;
        protected Node<T> next;
        public Node(T data){
            this.data =data;
        }
    }

5、内部类
内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。

public class OutClass {
    private int outA;

    public OutClass(){

    }
    public void outClassFun(){
        InnerClass innerClass = new InnerClass();
        innerClass.innerA = 10;  //外部类访问内部类必须通过对象访问
    }
    static class StaticInnerClass{ //静态内部类特点：只有一个this,不包含外部类对象
        private int innerA;
        public void fun(){
            this.innerA = 10;
        }
    }

    class InnerClass{  //实例内部类
        private int innerA;

        public InnerClass(){

        }
        public void funInner(){
            OutClass.this.outA = 10;  //内部类必须包含外部类对象
            this.innerA = innerA;
        }
    }

    public static void main(String[] args){
        OutClass outClass = new OutClass();
        OutClass.StaticInnerClass a = new OutClass.StaticInnerClass();
        OutClass.InnerClass b = outClass.new InnerClass();
    }
}

实例内部类包含两个this,一个是外部类的 OutClass.this，一个是内部类自己的；而静态内部类,不包含外部类对象。