JAVA类和对象

类是什么啊

什么是类？哦豁,它就是某个事物的本质，万物之源，是一个模板。

如何使用类

那么如上图所示，用class关键字来创建类，后面的跟着的就是你自己命名的类名（PS：规定是大驼峰）。
ok,接下来就是定义你的属性/成员变量和成员方法。你想怎么定义就怎么定义，开心就好。

对象是什么啊

此对象非彼对象，对象是一个具体的东西。通过类来进行实例化，在上面中，我们定义了一个Person类，那么现在我们就以用Psrson类来实例化对象了（借女娲之手）

Person person1=new Person();
Person person2=new Person();

对象调用类的东西

通过new Person(),我们造出来了两个人。现在赋予他们属性，给个名字，给个年龄。

 person1.name="张三";
 person1.age=23;
 person2.name="李四";
 person2.age=25;

再用tostring（右击，generate）给他把属性打印出来

This引用

当我们在类中定义成员方法时，里面的参数如果和成员变量相同了，那么在对象调用成员方法时，进行赋值，就不会成功。

那么我们就可以加一个this来代表当前对象的引用，这样就可以进行完美输出。

this用法

this.成员变量

this.成员方法

this.构造方法

构造方法是啥啊

构造方法是类中特殊的方法，要求它的名字要和类名相同，且不要求写返回值

如上图所示，这就是构造方法，值得一提的是，编译器本身也会给我们提供一个默认的构造方法，当我们不去主动去写的时候。一旦我们自己写了构造方法，那么编译器就不会再给我们使用默认构造方法。
有了构造方法，我们也多了另一种赋值方式。

构造方法也可以进行重载，快捷键（右击–generate–constructor）

封装

为什么会有封装？因为要降低代码的耦合度，使得关联程度不会那么低，利用封装，可以对类的实现细节进行隐藏。

访问权限修饰符

public 可以在任何情况访问类中的成员方法和成员变量
private 只能在本类中访问类中的成员方法和成员变量
default 可以访问同一包中的不同子类
protected (暂时不太清楚)

static关键字

在类中用关键字static修饰的成员方法或成员变量，可以直接通过（类名.）直接去访问

实例代码块

优先构造方法执行

静态代码块

优先实例代码块执行

内部类

内部类的意为在类中还可以创建另外一个类

实例内部类

//创建内部类对象；
Student student=new Student();
Student.Color color=student.new Color();

实例内部类当中不能定义静态的成员变量？

  public static final int data8=90;//加一个final

内部类里面，成员变量和外面类重名了，打印的时候，会输出内部类中的成员变量的值，那么如何避免呢？（暂不清楚）

静态内部类

//创建对象
Student.Name name=new Student.Name();
        name.cry();

类只有两个修饰符
一个是public;一个是默认权限。

匿名内部类

使用场景：线程使用

基类、父类

通过父类，可以生产出许多子类

子类、派生类

子类就可以通过extends关键字继承父类的成员方法和成员属性。如图

当子类的成员变量和父类的成员变量重名了

这个时候是优先访问局部变量，打印输出给子类的成员变量值的。如果想要打印父类的成员变量，那么我们就需要使用super关键字了。

当子类成员方法和父类成员方法重名且参数相同时

也是用super关键字加以区分

super

super.成员变量；
super.成员方法；
super.构造方法；
注意的是，super不能用在静态方法中哦；

面试官提问何为封装，何为继承

封装：在实现上采用Privater修饰成员变量和成员方法，来对类的内部实现细节进行隐藏，对外提供公开的方法进行调用。
继承：来实现对代码的复用，对多个类的共性进行提取
当我们构造子类的时候，一定要先帮助父类进行构造

public Cat(String name){
        super(name);//当构造子类的时候，一定要先帮助父类进行构造，为什么呢？
        System.out.println("这是子类构造方法");
    }

父类、子类中静态代码块、实例代码块、构造方法执行顺序

静态代码块只会执行一次，有多个对象的时候，所以也只会输出一次。

protected访问权限修饰符

不同包中的子类，就是说子类和父类不在同一个包中，但是被protected修饰后依然是可以访问的，前提是这个类是public修饰的

Java不支持多继承

如果一个类不想被继承，就加一个final //密封类
但在实际情况中，还是组合用户的比较多一点。类似这种

多态

简单来讲，同一件事，不同的人做有不同的结果
我们首先要明白这几个意思
1.向上转型
2.方法重写
3.多态

向上转型

向上转型的意思就是说，我父类可以使用你子类里的东西。
向上转型有三种方式

父类：Animal 子类：Cat
第一种方式：直接赋值
Animal animal=new Cat();
animal.eat();
第二种:方法的参数
  public static void func(People people){
        people.name="哈德";
        people.exercise();
    }
    public static void main(String[] args) {
        Men men=new Men();
        /*people.name="哈德";
        people.eat();*/
        func(men);
    }
第三种：方法的返回值
 public static People func1(){
        return new Women();
    }
    public static void main(String[] args) {
        Men men=new Men();
        /*people.name="哈德";
        people.eat();*/
        func(men);
        People people=func1();
        people.name="贾敏";
        people.exercise();
    }
}

方法重写

其实我们上面就已经进行方法重写，当方法名称、方法的返回值、方法的参数列表相同，那么当父类的引用去调用成员方法时，就会指向子类的成员方法。
@Override
多态的基础—动态绑定（暂时不理解）

不能被重写的情况

1. 静态方法不能被重写
2. private方法不能被重写
3. 被final修饰的方法不能被重写

重写场景（暂时不晓得）

向下转型（父类给子类）

 People people = new Men();
        if (people instanceof People) {
            Men men = (Men) people;
            men.name = "台州";
            men.exercise();
        }

理解多态

未完待续。。。。