Java 继承
所有Java的类均是由java.lang.Object类继承而来的，所以Object是所有类的祖先类，而除了Object外，所有类必须有一个父类。java只支持单继承，多继承用接口来实现。python支持多继承
extends关键字：通过使用关键字extends，子类可以继承父类的除private属性外所有的属性。
通过使用instanceof 操作符，能够确定子类是不是一个父类
Implements关键字：使用在类继承接口的情况下， 这种情况不能使用关键字extends
Java 重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变。即外壳不变，核心重写。重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
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 类的方法
}
}
子类中重写了父类的方法后又想再调用父类的这个方法，用super关键字
Java 重载
重载（overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型呢？可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
class Numers{
public Numers(){
}
public void count(int a,int b){
System.out.println("there are two numers");
}
public void count(int a){
System.out.println("there is one number");
}
}
public class JichenTest {
public static void main(String args[])
{
Numers aNumers = new Numers();
aNumers.count(1,2);
aNumers.count(1);
}
}
output:
there are two numers
there is one number
重写与重载之间的区别
| 区别点 | 重载方法 | 重写方法 |
|---|---|---|
| 参数列表 | 必须修改 | 一定不能修改 |
| 返回类型 | 可以修改 | 一定不能修改 |
| 异常 | 可以修改 | 可以减少或删除，一定不能抛出新的或者更广的异常 |
| 访问 | 可以修改 | 一定不能做更严格的限制（可以降低限制 |
Java 多态
多态是同一个行为具有多个不同表现形式或形态的能力。多态性是对象多种表现形式的体现。
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
因为Deer类具有多重继承，所以它具有多态性。以上实例解析如下：
- 一个 Deer IS-A（是一个） Animal
- 一个 Deer IS-A（是一个） Vegetarian
- 一个 Deer IS-A（是一个） Deer
- 一个 Deer IS-A（是一个）Object
虚方法
class Employee{
String name;
public Employee(String name){
this.name =name;
}
public void check(){
System.out.println("this is an Employee class");
}
}
class Salary extends Employee{
public Salary(String name){
super(name);
}
public void check(){
System.out.println("this s salary class");
}
}
public class Xuways {
public static void main(String args[]){
Salary asalary = new Salary("salarytest");
Employee aEmployee = new Salary("employeetest");
asalary.check();
aEmployee.check();
}
}
虽然 aEmployee用的是Employee的引用，但是但new 的是salary类型， 编译的时候，编译器使用Employee中check()方法验证该语句，但是在运行的时候，java虚拟机调用的Salaryde 的check( )方法
Java 抽象类
抽象类：
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能直接实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
抽象方法
如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。
Abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。
抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。
public abstract class Employee
{
private String name;
private String address;
private int number;
public abstract double computePay();
//其余代码
}
如果一个类包含了抽象方法，那么该类必须是抽象类
继承抽象方法的子类必须重写父类的抽象方法，否则该子类也必须声明为抽象类
Java 封装
一个类中定义的变量为了不让外部随意访问和修改，一般都会对该变量设置get和set方法，称之为封装
Java 接口
是个抽象类型，是抽象方法的集合，通常用interface来声明。一个类通过继承接口的方式来继承接口的抽象方法。接口无法被实例化，但可以被实现。接口的类型和其中包含的方法都是抽象的，默认是abstract，这个关键字可省略。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
interface Animalactions{
public void move();
public void bark();
}
class Animal implements Animalactions{
public void move(){
System.out.println("this is move");
}
public void bark(){
System.out.println("this is bark");
}
}
public class InterfaceTest {
public InterfaceTest(){
}
public static void main(String args[]){
Animal aanimal = new Animal();
aanimal.bark();
System.out.println(aanimal instanceof Animalactions);
}
}
output:
this is bark
true
接口的继承：一个接口继承另一个接口，可以多继承，用关键字extend
标记接口：没有任何方法的接口被称为标记接口
Java包
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
包的作用：
- 1 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
- 2 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
- 3 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
如果调用的类不在包中，就要使用全名（xxpackage.xx）或者导入该class(import xxpackage.xxx)