目录
一、包
包 (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 | 子类限制 | 一个子类只能继承一个抽象类 | 一个子类可以实现多个接口 |
原文链接：https://blog.csdn.net/qq_50156012/article/details/123612421