Java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分
成员变量名：成员变量名只要是一个合法的标识符即可，建议成员变量名应该由一个或多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。
方法名：方法名的命名规则与成员变量的命名规则基本相同，但由于方法用于描述该类或该类的实例的行为特征或功能实现，因此通常建议方法名以英文动词开头。
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
继承的特性
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
================================================================================================================
=================================================================================================================
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
多态存在的三个必要条件
继承
重写
父类引用指向子类对象：Parent p = new Child();
正常的继承关系中：
父子类继承关系着中：
1、子类可以拥有父类的变量；
2、子类可以拥有父类的方法；
父子类继承关系中：
如果变量名重名，则创建子对象时，有2种访问方式：（等号左边是谁，则优先用谁，没有则向上找）
1、创建父类对象，则只能使用父类的变量，没有任何子类类容； Animal anl = new Animal();
2、创建子类对象，则访问的是子类中的变量； Cat ct = new Cat();
Cat ct = new Cat();
父类和子类中有相同的成员变量，则访问的是子类中的成员变量；
父类和子类中有相同的成员方法，则访问的是子类中的成员方法；
================================================================
多态： ——向上转型
Animal an = new Cat();
左边父亲，右边儿子的继承关系中： 父类引用指向子类对象（左父右子） 子类对象被当做父类使用。
格式：
父类名称 对象名 = new 子类名称（）；
或者
接口名称 对象名 = new 实现类名称（）；
成员变量：
父子类有相同成员变量时。（等号左边是谁，则优先用谁，没有则向上找） //访问的是父亲中的变量
父亲中有此变量，子类中没有有此变量， //访问的是父类中的变量
父亲中没有此变量，子类中有此变量， //则访问此变量时，报错。
成员方法：
父子类有相同方法时。new的是谁，就使用谁。 //父子都有，优先用子
父亲有单独方法，子类没有此方法时。可以访问父类特有方法。 //子类没有，父类有，则向上找到父类
父亲中没有此方法，子类有此方法时， //访问此方法时，报错
============================================================================
============================================================================
向下类型转换
Animal as = new Dog(); //向下类型转换，通过向下转型，解决了多态的弊端：不能访问子类中的特有方法。
Dog d2 = (Dog)as;
如果获取的是父类中有的变量（独一无二，子类中没有），子类中没有， 则获取成功，获取父类的中的变量；
如果获取的是子类中有的变量（独一无二，父类中没有），子类中有， 则获取成功；
父类中和子类中有相同变量，则显示子类变量
父类中和子类中有相同方法，则执行子类方法；
如果执行的是父类中的方法（独一无二，子类中没有），则执行父类中的方法
如果执行的是子类中的方法（独一无二，父类中没有），则执行子类中的方法
class Animal { public void move() { System.out.println("动物——可以移动——子类和父类同一个方法"); } public void name() { System.out.println("动物——name——父类独有的方法"); } }
class Dog extends Animal { public void move() { System.out.println("狗——可以跑和走——子类和父类同一个方法"); } public void bark() { System.out.println("狗——可以叫——子类单独有的方法"); super.move(); } } public class TestDog { public static void main(String args[]) { Animal b = new Dog(); //向上类型转换 b.name(); b.move(); //重写，父类和子类都有同名方法 // b.bark(); 父类中没有这个方法，会使用报错 System.out.println("+++++++++++++++++++++++++++"); Dog d = new Dog(); //这个就是单纯的继承 d.name(); d.move(); d.bark(); System.out.println("------------------------------"); Animal as = new Dog(); //向下类型转换，通过向下转型，解决了多态的弊端：不能访问子类中的特有方法。 Dog d2 = (Dog)as; d2.name(); d2.move(); d2.bark(); System.out.println("================================"); as.name(); as.move(); ((Dog) as).bark(); } }
public class Cat extends Animal { public String name = "Cat：猫"; public String str = "Cat：可爱的小猫"; public static String staticName = "Dog：我是喵星人"; public void eat() { System.out.println("Cat：吃饭"); } public static void staticEat() { System.out.println("Cat：猫在吃饭"); } public void eatMethod() { System.out.println("Cat：猫喜欢吃鱼"); } public static void main(String[] args) { // Animal an = new Cat(); //向上类型转换 ,不能调用子类特有的成员变量以及方法 // // System.out.println(an.name99); // System.out.println(an.name); // an.eat(); // // System.out.println("-----------------------------------"); // // Cat ct = new Cat(); //继承 // // System.out.println(ct.name99); // System.out.println(ct.name); // System.out.println(ct.str); // ct.eat(); // ct.eatMethod(); // // System.out.println("+++++++++++++++++++++++++++++++++++"); Animal animal = new Cat(); Cat cat = (Cat) animal; // 向下转型 // System.out.println(animal.name); // 输出Animal类的name变量 // System.out.println(animal.staticName); // 输出Animal类的staticName变量 System.out.println(cat.name99); System.out.println(cat.name); System.out.println(cat.str); cat.eat2(); cat.eat(); cat.eatMethod(); System.out.println("=============================++++++++++++++++++++++++++"); System.out.println(animal.name99); System.out.println(animal.name); animal.eat(); ((Cat) animal).eatMethod(); System.out.println(((Cat) animal).str); // animal.eat(); // 输出Cat类的eat()方法 // animal.staticEat(); // 输出Animal类的staticEat()方法 // System.out.println(cat.str); // 调用Cat类的str变量 // cat.eatMethod(); // 调用Cat类的eatMethod()方法 } }
=============================================================================================================
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
======================================================================================================================
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口特性
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别
1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
================================================================================================================================
// 使用 new 指定数组大小后进行初始化
int[] number = new int[5];
number[0] = 1;
number[1] = 2;
number[2] = 3;
number[3] = 5;
number[4] = 8;
// 使用 new 指定数组元素的值（2种方式）
int[] number2 = new int[] { 1, 2, 3, 5, 8,9,10};
// 直接指定数组元素的值（2种方式）
int[] number4 = { 1, 2, 3 };
如果程序员只指定了数组的长度，那么系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值。
- 数组元素的类型是基本类型中的整数类型（byte、short、int 和 long），则数组元素的值是 0。
- 数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的值是 0.0。
- 数组元素的类型是基本类型中的字符类型（char），则数组元素的值是‘\u0000’。
- 数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的值是 false。
- 数组元素的类型是引用类型（类、接口和数组），则数组元素的值是 null。