【Java语法】包 继承 多态 抽象类 接口

一、包

包 (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范围privatedefaultprotectedpublic1同一包中的同一类√√√√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区别thissuper1概念访问本类中的属性和方法由子类访问父类中的属性、方法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权限各种权限public3子类的使用extendsimplements4关系一个抽象类可以实现若干个接口接口不能继承抽象类，但是接口可以使用extends关键字继承多个父类接口5子类限制一个子类只能继承一个抽象类一个子类可以实现多个接口