继承的概念
继承是面向对象的第二大特征。
继承是从已有的类派生出一个新类，叫子类，子类可以继承父类非私有化的方法。
语法格式：
class 类名(子类) extends(子类) 类名{
}继承的实现代码
class Father{
//成员属性
//成员方法
}
class Son extends Father{
//成员属性
//成员方法
}重写
重写定义：在一个子类中有与父类相同的方法名和参数方法，该方法叫做重写。
目的：父类的需求满足不了子类的需求，这个时候子类就要重写父类非私有话的方法。
重写用关键字Overidde
重写的实现代码：
class Father{
//成员属性
public void eat(){
System.out.println("吃肉");
}
}
class Son extends Father{
//成员属性
//重写
@Override
public void eat() {
System.out.println("我吃面条");
}
}注意：只能重写父类非私有话的方法。
重载
重载定义：在一个类中有很多方法，方法名一样，参数不一样，我们称为重载。
代码实现：
package com.qfedu.d_override;
class Person {
//在一个类中，方法法名字一样，但是参数一定不一样。这叫方法的重载
//返回值可以不一样
public void test () {
System.out.println("test");
}
public void test (String name) {
System.out.println(name);
}
public void test (int i) {
System.out.println(i);
}
void test (double d1) {
}
public String test(String str1, String str2) {
return str1 + str2;
}
}
public class Demo3 {
public static void main(String[] args) {
}
}总结：
1.方法的重载必须在同一个类中
2.方法名字必须一致
3.方法的参数类型必须不一样
4.方法的返回值可以不一样
5.无参构造和有参构造 也是一种重载
super关键字
只能用于继承，并在子类中使用。代表的是父类对象。
super用法：
1.可以调用父类中的属性和方法
2.可以调用父类的构造方法
入门案例：
package com.qfedu.b_super;
class Father1 {
String name;
public Father1 () {
System.out.println("Father1的无参构造");
}
public Father1 (String name) {
System.out.println("Father1有参构造");
}
}
class Son1 extends Father1 {
//在子类中无论你写了有参构造和无参构造，都要去执行父类的无参构造
//除非你自己调用父类有参构造方法
public Son1(String name) {
//在调用父类的无参构造方法
//super();
super("狗蛋");
}
}
public class Demo2 {
public static void main(String[] args) {
Son1 son1 = new Son1("狗蛋");
}
}抽象类
如果一个类中没有足够的信息来描述具体的对象，那么这个类叫抽象类。
用关键字abstract修饰
abstract关键字
abstract修饰的类叫抽象类
abstract修饰的方法叫抽象方法
语法格式：
abstarct class 类名｛
普通的方法;
public void eat () {
}
抽象方法;
public abstarct void sleep ();
｝入门案例：
package com.ymk.csdn;
abstract class Person{
//普通成员方法
public void eat(){
System.out.println("吃什么");
}
//抽象方法
abstract public void play();
}
class Student extends Person{
@Override
public void play() {
System.out.println("踢足球，跑步");
}
}在上述代码中，我们定义了一个抽象类，抽象类里有两个方法，普通成员方法和抽象方法，由于抽象方法不能实例化，抽象方法也没有方法体，是个不完整的方法，所以我们只能通过一个普通的类去继承它，并且在子类中去重写所有的抽象方法。
总结：
1.如果一个类中有abstract修饰，那么这个类就是抽象类
2.抽象类中可以有普通抽象方法和抽象方法
3.抽象方法没有方法体，是 不完整的方法
4.抽象类不能实例化
5.创建一个普通类继承抽象类
6.在子类中去重写抽象类中所有的抽象方法
7.非抽象方法可以重写也可以不重写
8.抽象类可以继承另一个抽象类
9.抽象类可以继承非抽象类
final关键字
用法：
1.final可以修饰成员变量
使用final修饰的成员变量，一定要赋值（初始化）。而且不能修改。
2.final可以修饰局部变量
使用final修饰局部变量的时候，可以先对变量不赋值，使用之前进行赋值。
但是一旦赋值以后就无法更改。
3.final可以修饰成员方法
final修饰的成员方法不能被重写，牵涉到继承
4.final可以修饰一个类
final修饰的类不能被继承
5.final可以修饰对象的引用
修饰对象引用 一旦被赋值 就无法改变
代码实现：
class Person {
final String name = "狗蛋";
public void test () {
final int i;
i = 30;
//i = 80;//一旦被赋值，就无法改变了
System.out.println(i);
}
public final void eat () {
System.out.println("吃饭");
}
}
//class Man extends Person {
// @Override
// public void eat() {
// System.out.println("吃的多");
// }
//}
public class Demo1 {
public static void main(String[] args) {
final Person person = new Person();
System.out.println("Person:" + person);
//一旦使用final修饰person 对象引用 是一个固定的内存地址
Person person1 = new Person();
System.out.println("Person1:"+ person1);
//person.name = "嘻嘻";
//person = person1;//将person1赋值给了person对象
System.out.println(person);
}
}接口
语法格式：
interface 接口名字 {
成员变量
成员方法
}实现接口用关键字implements
入门案例：
interface A{
String name = "接口";
public void eat();
public void sleep();
}
class B implements A{
@Override
public void eat() {
System.out.println("吃好饭");
}
@Override
public void sleep() {
System.out.println("睡好觉");
}
}
public class Demo2 {
public static void main(String[] args) {
B b = new B();
b.eat();
b.sleep();
System.out.println(b.name);
}
}接口注意事项：
1.使用关键字 interface 声明出来一个接口
2.接口面可以有属性，但是是static 和final修饰的属性。被称为常量。几乎不用
3.接口下面全部抽象的方法，不带方法体的
4.jdk1.8以后是可以有默认（default）的方法的，这个默认方法带有方法体【重点！！！】
5.接口下面没有构造方法，不能被实例化
6.去使用一个普通的类去实现这个接口，使用关键字implements
7.一定要在实现类中去实现所有的抽象方法
8.一个普通的类可以实现多个接口，弥补了单继承的局限性
9.一个接口可以去继承另外一个接口
