包 (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	子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口