继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
1.继承的格式
class 父类 {
}
class 子类 extends 父类 {
}
2.继承的特点与好处
特点:只支持单继承,不支持多继承，但支持多重继承。
好处:提高了代码的复用性,提高了代码的维护性
3.super与this关键字的特点
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
4.final
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
//声明类
final class 类名 {//类体}
//声明方法
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
5.继承中构造方法的访问
1)子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
2)如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
二.方法的重载与重写1.重写(Override)
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
2.重载(Overload)
重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
public class Overloading {
public int test(){
System.out.println("test1");
return 1;
}
public void test(int a){
System.out.println("test2");
}
//以下两个参数类型顺序不同
public String test(int a,String s){
System.out.println("test3");
return "returntest3";
}
public String test(String s,int a){
System.out.println("test4");
return "returntest4";
}
public static void main(String[] args){
Overloading o = new Overloading();
System.out.println(o.test());
o.test(1);
System.out.println(o.test(1,"test3"));
System.out.println(o.test("test4",1));
}
}
三.多态
多态是同一个行为具有多个不同表现形式或形态的能力。
1.前提条件
1)需要存在继承关系
2)存在方法重写,子类继承父类,将部分功能进行重写
3)必须存在:父类引用指向子类对象:向上转型
2.格式
父类名 对象名 = new 子类名( ) ;
3.多态的成员访问特点
成员变量
编译看左,运行看左
成员方法
编译看左,运行看右 (因为存在方法重写,所以子类的功能将父类的功能覆盖了)
静态方法
编译看左,运行看左 (不属于方法超重写,可以用类名直接访问)
构造方法
有参方法/无参方法
4.多态的好处与弊端
好处
1).提高代码的复用性
2).提高代码的扩展性
四.抽象类如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类不能直接实例化,但是可以通过具体的子类进行实例化,抽象类多态;
1.格式
抽象的父类名 对象名 = new 具体的子类名 () ;
2.声明抽象方法
- 如果一个类包含抽象方法，那么该类必须是抽象类。
- 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
3.抽象方法
Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。
public abstract class Employee {
private String name;
private String address;
private int number;
public abstract double computePay();
//其余代码
}
4.抽象类总结
- 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
- 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
- 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
- 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
- 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类
接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
1.接口的特性
- 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
2.接口的声明
1)声明语法格式
interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
2)implements:实现关系
import java.lang.*;
//引入包
public interface NameOfInterface {
//任何类型 final, static 字段
//抽象方法
}
3.接口的实现
public class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
public static void main(String args[]){
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
4.接口的继承
一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法
// 文件名: Sports.java
public interface Sports {
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}
// 文件名: Football.java
public interface Football extends Sports {
public void homeTeamScored(int points);
public void visitingTeamScored(int points);
public void endOfQuarter(int quarter);
}
// 文件名: Hockey.java
public interface Hockey extends Sports {
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}
六.内部类
1.什么是内部类
在一个类中定义另一个类;
2.内部类的分类
成员内部类:在外部类的成员位置中定义
局部内部类:在外部类的局部位置中定义(方法定义中)
3.内部类特点
都可以直接访问外部类的成员,包括私有!
4.访问成员内部类格式
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
5.访问静态成员内部类格式
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
6.匿名内部类格式
new 类名(抽象类)/接口名(){
重写抽象方法
};
七.局部变量和成员变量的区别？
1).位置不同
局部变量:在方法定义中或者方法声明上
成员变量:在类中,方法外
2).作用位置不同
局部变量:在栈内存中
成员变量:在堆内存中
3).生命周期不同
局部变量:随着方法的调用而存在,随着方法调用结束而消失
成员变量:随着对象的创建而存在,随着对象的创建完毕等待垃圾回收器回收而消失
4).初始化不用
局部变量:在使用之前必须将其初始化;
成员变量:可以不初始化,系统会给出默认的值
1).数据存储位置不同
静态变量:方法区中的静态区域
成员变量:在堆中
2).别名不同
静态变量;跟类有关
成员变量:跟对象有关
3).生命周期不同
静态变量:随着类的加载而加载
成员变量;随着对象的创建而存在
4).调用方式不同
静态变量:使用对象名访问
成员变量:通过对象访问
1).成员区别
抽象类:成员变量:可以是常量,也可以是变量
成员方法:可以是抽象方法,也可以是非抽象方法
构造方法:无参构造,有参构造方法都有
接 口: 成员变量:只能是常量
成员方法:只能是抽象方法
构造方法:没有构造方法
2).关系区别
类与类之间的继承关系,只能单继承,不能多继承,可以多层继承
类与接口之间用implements实现,一个类继承另一个类时可以实现多个接口
接口与接口的关系是继承extends
3).设计理念不同
抽象类;存在继承关系,体现is a
接口:接口体现的一种事物本身之外的额外功能,和类时一种实现关系
