父类private的东西子类也是可以继承过来的，只是因为封装的特性阻碍了直接调用，但是可以通过暴露出来的方法（get/set）进行间接调用
某种程度上说，父类是大于子类的, 子类有更多的约束，所以小于父类
在特殊情况下，当子类和父类属性重名时，你要想使用父类的属性，必修加上修饰符super, 只能通过super.属性调用
在特殊情况下，当子类和父类方法重名时，你要想使用父类的方法，必修加上修饰符super,只能通过super.方法调用
其实我们平时写的空构造器第一行都有：super() –> 作用：调用父类的空构造器，只是我们一般都省略不写
如果构造器中已经显式的调用super父类构造器，那么它的第一行就没有默认分配的super()了，如果构造器中没有显式的调用super()构造器，那么第一行都会默认调用super(),可以省略不写
所有类都直接或间接继承自Object类，Object类是所有Java类的根基类
也就意味着所有Java对象都拥有Object类的属性和方法
如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类
Object的toString()方法
正确比较 两个double 是否一样，，调用方法返回一个long类型的数 //或者调用Double.compare()
比较两个对象是否相等要重写hashcode 和 equals这两个方法，，，/一定要重写 Hashcode() 方法
类和类之间可以产生的关系：
1.类和类之间可以作为方法的形参
2.类和类之间可以作为类的属性
父类到子类是继承，子类到父类是泛化
多态的好处：
为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。
开闭原则：指的是扩展是开放的，修改是关闭的
多态的三要素：
一 继承 Cat extends Animal
二 重写
三 父类引用指向子类对象
简单工厂设计模式：
//第四种情况：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//第1种情况：
//final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
final int A = 10;//final修饰基本数据类型
//A = 20; 报错：不可以修改值
//第2种情况：
final Dog d = new Dog();//final修饰引用数据类型，那么地址值就不可以改变
//d = new Dog(); -->地址值不可以更改
//d对象的属性依然可以改变：
d.age = 10;
d.weight = 13.7;
//第3种情况：
final Dog d2 = new Dog();
a(d2);
//第4种情况：
b(d2);
}
public static void a(Dog d){
d = new Dog();
}
public static void b(final Dog d){//d被final修饰 ，指向不可以改变
//d = new Dog();
}
}
在同一个类中，只能有一个类被public修饰，且被public修饰的类名和原文件名一样
final修饰方法，那么这个方法不可以被该类的子类重写：
final修飾类
final修饰类，代表没有子类，该类不可以被继承：
一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写
MATH类
抽象类：
【1】抽象类和抽象方法的关系：
抽象类中可以定义0-n个抽象方法。
【2】抽象类作用：
在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。
使子类更加的通用
package com.msb.test03;
//4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
public abstract class Person {
//1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
public void eat(){
System.out.println("一顿不吃饿得慌");
}
//2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
//3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
public abstract void say();
public abstract void sleep();
}
//6.抽象类可以被其他类继承：
//7.一个类继承一个抽象类，那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
//9.子类继承抽象类，就必须重写全部的抽象方法
//10.子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。
class Student extends Person{
@Override
public void say() {
System.out.println("我是东北人，我喜欢说东北话。。");
}
@Override
public void sleep() {
System.out.println("东北人喜欢睡炕。。");
}
}
class Demo{
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//11.创建抽象类的对象：-->抽象类不可以创建对象
//Person p = new Person();
//12.创建子类对象：
Student s = new Student();
s.sleep();
s.say();
//13.多态的写法：父类引用只想子类对象：
Person p = new Student();
p.say();
p.sleep();
}
}
4】面试题：
（1）抽象类不能创建对象，那么抽象类中是否有构造器？
抽象类中一定有构造器。构造器的作用 给子类初始化对象的时候要先super调用父类的构造器。
（2）抽象类是否可以被final修饰？
不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。
接口中没有构造器
在 JDK 1.8 之前， 接口中只有两部分内容：
（1） 常量 ： 被 public static final 修饰
（2）抽象方法：固定修饰符： public abstract
注意：修饰符可以省略不写， IDE会自动补全，但是建议写上，防止遗忘
- 类和接口的关系？ 实现关系 类实现接口
- 一旦实现一个接口，那么实现类要重写接口中全部的抽象
- 如果没有全部重写抽象方法，那么这个类可以变成一个抽象类
- java只有单继承，java还有多实现
-
一个类继承其他类，只能继承一个父类，但是实现类实现接口的话，可以实现多个接口
10.接口不能创建对象 ，可以父类引用指向子类对象
继承 ： is-a
实现： has-a
多态的应用：
（1）父类作为方法的形参，传入具体的子类的对象
（2） 父类当作方法的返回值，返回的是具体子类的对象
（3）接口当作方法的形参，传入具体的实现类的对象
（4）接口当作方法的返回值，返回的是具体的子类的对象
在 JDK 1.8之后，新增非抽象方法：
（1） 被public default修饰的非抽象方法
注意1：default修饰符必须要加上，否则出错
注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。
（2）静态方法：
注意1：static 不可以省略不写
注意2：静态方法不能重写，只能被覆盖
疑问：为什么要在接口中加入非抽象方法？
如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响
内部类：
- 类的组成： 属性，方法，构造器，代码块{ 普通块，静态块，构造块，同步块} ， 内部类
- 一个类的内部的类叫内部类
- 内部类 ： 成员内部类 和 局部内部类 （位置：方法内，块内，构造器内）
- 成员内部类：
- 里面修饰属性，方法，构造器等
- 修饰符：private,default,protect,public ,final
- 内部类可以访问外部类中的内容 // 静态内部类中只能访问外部类中被static修饰的内容 不能访问非静态的内容
-
//外部类要访问内部类的东西要创建内部类对象再调用
10.
创建静态内部类对象：
外部类类名.静态类名 xxx = new 外部类类名.静态类（）；
创建非静态内部类对象：
外部类类名.类名 xxx = new 外部类类名.() . new 内部类类名（）；
局部内部类中的方法访问外部类中的属性要被final修饰？
匿名内部类：
一个效果