【Java语法】包 继承 多态 抽象类 接口
目录
一、包
二、继承
继承
protected 关键字
四种访问权限
final关键字
三、多态
向上转型
动态绑定
方法重写
重载和重写的区别
super 关键字
super与this的区别
四、抽象类
抽象类
接口
接口与抽象类区别
一、包
包 (package) 是组织类的一种方式. 使用包的主要目的是保证类的唯一性
将类将放到包中
基本规则
在文件的最上方加上一个 package 语句指定该代码在哪个包中.
如果一个类没有 package 语句, 则该类被放到一个默认包中
包的访问权限控制
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.
二、继承
继承
对共性的抽取，使用extends关键字进行处理，可以对代码重复使用
语法规则
继承对象叫做子类、派生类
被继承对象叫做父类、基类、超类
基本语法
class 子类 extends 父类 {
} 1，Java当中的继承是单继承，不能同时继承两个以上的类，包括两个
2，子类构造的同时，要先帮父类进行构造，子类帮助构造，使用构造方法
3，对于父类的 private 的字段和方法, 子类中是无法访问的
4，子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用
5，如果一个类不想被继承，可以使用final修饰
class Animal {
public String name = "hello";
public int age;
protected int count;
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name+"eat()");
System.out.println(count);
}
}
class Dog extends Animal{
public Dog(String name,int age) {
super(name,age);
}
}
class Bird extends Animal{
public String wing;
public String name;//null
public Bird(String name,int age,String wing) {
super(name,age);
this.wing = wing;
}
public void fly() {
System.out.println(super.name+"fly()"+age);
}
}
public class Text1 {
public static void main(String[] args) {
Dog dog = new Dog("haha",19);
System.out.println(dog.name);
System.out.println(dog.age);
dog.eat();
}
}
super关键字
不能出现在静态的方法中，父类对象的引用
1，super()调用父类的构造方法
2，super.func()
3，super.data
protected 关键字
刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷. 两全其美的办法就是 protected关键字
1，对于类的调用者来说, protected 修饰的字段和方法是不能访问的
2，对于类的子类和同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的
四种访问权限
| NO | 范围 | private | default | protected | public |
| 1 | 同一包中的同一类 | √ | √ | √ | √ |
| 2 | 同一包中的不同类 | √ | √ | √ | |
| 3 | 不同包中的子类 | √ | √ | ||
| 4 | 不同包中的非子类 | √ |
final关键字
1，修饰一个变量或者字段的时候, 表示 常量 (不能修改).
2，final 关键字也能修饰类, 此时表示被修饰的类就不能被继承
三、多态
向上转型
1，直接赋值
2，函数的参数
3，方法返回
class Animal {
public String name = "hello";
public int age;
protected int count;
public Animal(String name,int age) {
eat();
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name+" ani::eat()");
}
}
class Dog extends Animal {
public Dog(String name,int age) {
super(name,age);
}
}
public class Text1 {
public static void main(String[] args) {
Animal animal = new Dog("花花",19);//父类引用子类对象
}
}动态绑定
1，父类引用子类对象
2，通过这个父类引用调用父类和子类同名的覆盖方法
class Animal {
public String name;
public int age;
protected int count;
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name+" ani::eat()");
}
}
class Dog extends Animal {
public Dog(String name,int age) {
super(name,age);
}
@Override
public void eat() {
System.out.println(name+" 狼吞虎咽的eat()");
}
}
public static void main(String[] args) {
//通过父类引用只能访问父自己的成员
Animal animal1 = new Dog("花花",3);
animal1.eat();
Animal animal2 = new Bird("蛋蛋",4,"飞翔");
animal2.eat();
System.out.println(animal2.name);
}
方法重写
1，方法名相同
2，参数列表相同（个数+参数类型）
3，返回值相同
4，方法不可以是static
5，子类的访问修饰限定，要大于等于父类
6，private方法不能够重写，被final修饰的方法不能被重写
class Animal {
public String name = "hello";
public int age;
protected int count;
public Animal(String name,int age) {
eat();
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name+" ani::eat()");
}
}
class Dog extends Animal{
public Dog(String name,int age) {
super(name,age);
}
@Override
public void eat() {
super.eat();
}
}
class Bird extends Animal{
public Bird(String name, int age) {
super(name, age);
}
@Override
public void eat() {
super.eat();
}
}
重载和重写的区别
| NO | 区别 | 重载 | 重写 |
| 1 | 概念 | 方法名相同，参数的个数和类型相同 | 方法名名称，返回值类型，参数的类型及个数完全相同 |
| 2 | 范围 | 一个类 | 继承关系 |
| 3 | 限制 | 没有权限要求 | 被覆写的方法不能拥有比父类更严格的访问权限 |
super 关键字
不能出现在静态的方法中，父类对象的引用
1，super()调用父类的构造方法
2，super.func()
3，super.data
class Animal {
public String name = "hello";
public int age;
protected int count;
public Animal(String name,int age) {
eat();
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name+" ani::eat()");
}
}
class Dog extends Animal{
public Dog(String name,int age) {
super(name,age);
super.eat();
}
@Override
public void eat() {
super.eat();
}
}
super与this的区别
| NO | 区别 | this | super |
| 1 | 概念 | 访问本类中的属性和方法 | 由子类访问父类中的属性、方法 |
| 2 | 查找范围 | 先查找本类，如果本类没有就调用父类 | 不查找本类而直接调用 |
| 3 | 特殊 | 表示当前对象 | 无 |
四、抽象类
抽象类
1，包含抽象方法的类，叫做抽象类
2，抽象方法，一个没有具体的实现的方法，被abstract修饰
3，抽象类不能被实例化，所以只能被继承
4，抽象类中可以包含和普通类一样的成员和方法
5，一个普通类，继承一个抽象类，这个普通类需要重写这个抽象类的所有抽象方法
6，抽象类最大作用就是为了被继承
7，一个抽象类A继承抽象类B，A可以不实现抽象父类B的抽象方法
8，抽象类不能被final修饰，抽象方法也不能被final修饰
9，针对7，普通类继承A，那么必须重写A和B的抽象方法
abstract class Shape {
public void func() {
System.out.println("测试普通方法！");
}
public abstract void draw();//抽象方法
}
abstract class A extends Shape{
}
class V extends Shape{
@Override
public void func() {
super.func();
}
@Override
public void draw() {
}
}
abstract class Shape {
public void func() {
System.out.println("测试普通方法！");
}
public abstract void draw();//抽象方法
}
abstract class A extends Shape{
public void count(){
System.out.println("sdspjd");
}
}
class V extends Shape{
@Override
public void func() {
super.func();
}
@Override
public void draw() {
}
}
class B extends A{
@Override
public void func() {
super.func();
}
@Override
public void draw() {
}
}
接口
1，使用interface来修饰
2，接口当中的普通方法，不能有具体的实现。非要实现通过关键字default来修饰
3，接口中可以有静态方法，里面所有的方法都是public
4，抽象方法，默认是public abstract的
5，接口不可以通过关键字new来实例化
6，类和接口之间的关系通过implenebts实现
7，当一个类实现了一个接口，必须要重写接口中的抽象方法
8，接口成员变量默认是public static final修饰的
9，当一个类实现一个接口，重写这个方法的时候，必须加上public
10，一个类可以通过关键字extends继承一个抽象类或者普通类，但是只能继承一个类。同时，也可以通过implements实现多个接口，接口之间用逗号隔开
interface IShape {
void draw();//抽象方法
}
class Rect implements IShape {
@Override
public void draw() {
System.out.println("♦");
}
/*@Override
public void func() {
System.out.println("重写接口当中的默认方法");
}*/
}
class Flower implements IShape {
@Override
public void draw() {
System.out.println("❀");
}
}
class Triangle implements IShape {
@Override
public void draw() {
System.out.println("△");
}
}
class Cycle implements IShape {
@Override
public void draw() {
System.out.println("●");
}
}interface IA {
int A = 10;
void funcA();//public abstract
}
interface IB {
void funcB();
}
abstract class BClass {
}
class AClass extends BClass implements IA,IB {
public void funcA() {
System.out.println("A::funcA()");
System.out.println(A);
}
@Override
public void funcB() {
System.out.println("A::funcB()");
}
}
接口与抽象类区别
| NO | 区别 | 抽象类 | 接口 |
| 1 | 结构组成 | 普通类+抽象方法 | 抽象方法+全局变量 |
| 2 | 权限 | 各种权限 | public |
| 3 | 子类的使用 | extends | implements |
| 4 | 关系 | 一个抽象类可以实现若干个接口 | 接口不能继承抽象类，但是接口可以使用extends关键字继承多个父类接口 |
| 5 | 子类限制 | 一个子类只能继承一个抽象类 | 一个子类可以实现多个接口 |