今天的主要内容是构造方法，static用法，继承，多态，抽象类，接口。由于从今天开始JAVA的学习基本上都是面向对象的内容，虽然这些内容底层的实现是由C++写的编译器实现的，在用法上与C语言已经大相径庭，故不再比较二者的差异。开始阐释JAVA的知识点为主。
构造方法
所谓构造方法，就是在创建对象时自动执行的方法，主要用于对成员变量的初始化，当然也可以用于对运行环境的初始化，如加载驱动等。
空参构造
空参构造即以不传递参数的方式下创建对象。如Demo d = new Demo(); 就是用空参构造的方式创建对象，Demo后面的括号，就是用来传递参数的，当其为空时，便是空参构造。
空参构造方法
在类中编写的通过无参构造创建对象系统自动执行的方法。
空参构造方法没有返回值，连void也没有
空参构造方法与类同名
class Demo_constructor {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name+"..."+p.age); //张三...18
}
}
class Person{
String name;
int age;
public Person(){
name = "张三";
age = 18;
}
}
代码中通过空参构造方法Person()，对类中的name和age赋值为张三和18，在主方法中new一个Person对象的时候没有传递参数，系统自动执行空参构造方法，对象中的name和age便有了初值张三和18；
有参构造方法
当创建对象时传递参数，便自动执行有参构造方法。
有参构造方法与无参大致相同，只需在编写时写上参数列表即可。
class Demo_constructor {
public static void main(String[] args) {
Person p = new Person("张三",18);
System.out.println(p.name+"..."+p.age); //张三...18
}
}
class Person{
String name;
int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
}
当局部变量名与成员变量名的相同时，局部变量会隐藏成员变量，但在开发中常要求见名知意，对于这种情况，可以用this.来引用成员变量，与局部变量区分开来。
在写类的时候，倘若没有写构造方法，系统会自动加上空参构造，如果写了有参构造方法，没写空参构造方法，系统不再加上空参构造，在创建对象时便不可以用空参的方式创建，因此，在写完有参构造方法后尽量将空参构造方法也写上。
static
static是静态的意思，在类中定义static成员变量和static成员方法，这些方法是存放在内存的方法区中，在创建对象的时候，不需对这些变量和方法分配空间，可以达到资源共享的作用。
静态成员变量
静态成员变量由所有对象共享，在一个对象该变量修改后，所有的对象静态变量都会修改，因为他们其实都在引用同一个变量。
class Demo_static {
public static void main(String[] args) {
Person p = new Person();
p.name = "张三";
p.country ="中国";
p.speak(); //张三...中国
Person p2 = new Person();
p2.speak(); //null...中国
p2.country = "America";
p.speak(); //张三...America
}
}
class Person{
String name;
static String country; //在c语言的解释中就是将country声明周期延长，实现共享，节省空间资源
public void speak(){
System.out.println(name+"..."+country);
}
}
从代码中可以看到，创建对象p之后，将p的name和country修改为张三和中国，然后创建对象p2，虽然没有对p2的属性进行修改，但由于country是static变量，所以，p2的country也为中国，而非静态变量的name为null。然后p2将其变量country修改为America，p的变量country也变为了America。
静态成员方法
将类中的成员方法修饰为static，可以在不创建对象的情况下对方法进行引用，节省空间。其实主方法public static void main(String[] arg){}中，main就是JVM识别的入口，声明为static就可以在不创建该类的情况下调用主函数。
class ArrayTool {
private ArrayTool(){};
//若类只有静态方法,要设置私有构造方法,防止创建对象,浪费内存
public static int getMax(int[] arr){
int max = arr[0];
for (int i = 1;i < arr.length ;i++ ){
if (arr[i] > max){
max = arr[i];
}
}
return max;
}
}
上面定义的类中含有static方法，在主函数中可以不创建该类的对象而直接调用方法
class Array_Test {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
int max = ArrayTool.getMax(arr);
}
}
下面的内存分配图可以帮助我们更好的理解static的机制，了解static各个特点的原理
类中静态变量与静态方法内存分配
注意事项
共性用static,特性用auto
静态变量又叫类变量,非静态变量又叫对象变量
静态变量随类产生和消失,非静态变量随对象产生和消失
静态只能访问静态
继承
有时候类与类之间有很多相同的成员变量和方法，倘若全部都要重写，代码的复用性太低，不利于开发。怎么通过类与类之间的联系，减少代码量？继承由此诞生。
JAVA的继承通过extends实现，实现继承的类成为子类，被继承的类成为父类。子类继承了父类，相同的成员变量和方法不需重写便可使用，大大提高了代码的复用性。
class Demo_extends {
//让类与类之间产生关系,提高代码的复用性,维护性,也是多态的前提
public static void main(String[] args) {
Cat c = new Cat();
c.color = "白";
c.legs = 4;
System.out.println(c.color+"..."+c.legs);
}
}
class Animal{
String color;
int legs;
public void sleep(){
System.out.println("sleep");
}
}
class Cat extends Animal{
}
通过extends关键字,Cat类继承了Animal类，即使Cat中的代码块为空，仍然可以使用Animal中的成员变量和方法。
JAVA不支持多继承，只支持单继承，即一个子类只有一个父类，因为当两个父类中有同名的方式时会造成冲突，造成安全隐患。
JAVA在创建子类对象的时候，会先访问父类的构造方法，在访问子类的构造方法。从继承的设计理念来不难理解为什么要这么做，因为子类继承父类是为了使用父类的资源,所以在构造子类时要访问父类。
class Demo_extends3 {
public static void main(String[] args) {
Son s = new Son(); //这是父类构造,这是子类构造
} //在构造子类时会动访问父类构造
}
class Father{
int num1;
int num2;
public Father(){
System.out.println("这是父类构造");
}
}
class Son extends Father{
public Son(){ //所有的子类构造方法会默认访问父类的无参构造方法
//super(); //这是一条语句,没写会自动加上,用来访问父类
System.out.println("这是子类构造");
}
}
这种机制在父类对象没有空参构造的时候会出现错误，因为系统默认的super();语句是访问父类的空参构造方法，在这种情况下，要在子类的构造方法中进行处理，即用super语句访问父类的有参构造方法。
class Demo_extends4 {//关于父类没有无参构造的解决方法
public static void main(String[] args) {
Son s = new Son(1);
System.out.println("-----------------");
Son s2 = new Son();
}
}
class Father{
int num;
public Father(int num){
System.out.println("父类有参构造");
}
}
class Son extends Father{
public Son(){
super(1);
System.out.println("子类无参构造");
}
public Son(int num){
super(num);
System.out.println("子类有参构造");
}
}
对于在创建的时候，是否会创建父类对象，因为要调用父类构造方法，需要一个实例对象。网上的答案鱼龙混杂，有说要的，有说不要的。但从我查阅的资料看，在创建子类对象的时候不会创建父类对象。
从内存的使用来看，倘若在创建子类对象的时候创建父类对象，所有的对象都是Object的子类对象，那么内存必然会被各种Object对象充斥，可用内存少之又少，几乎不可能有可用内存。这与我们的显示显然是冲突的。
但是要使用父类构造方法，必须有一个实例，这个实例在哪？在知乎一个回答中看到，父类，子类的实例其实是同一个，也就是说在访问父类方法的时候，将该实例作为父类对象，在访问子类构造方法的时候，又把这个实例当做子类对象。这个实例中有一部分是地址用super表示，是作为父类的储存区，而其余部分是子类的储存区域，地址用this表示。
子类对象内存图
多态
编译和运行的时候产生不同的形态成为多态。
多态前提：要有继承，要有方法重写，要有父类引用子类对象
对于多态编译与运行时类中元素的规则
成员变量: 编译看左边(父类),运行看左边(父类);
成员方法: 编译看左边(父类),运行看右边(子类); 动态绑定
静态方法: 编译看左边(父类),运行看左边(父类);
class Demo_Polymorthic {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.num); //10
f.print(); //Son
f.speak(); //fat
}
}
class Demo_Polymorthic {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.num); //10
f.print(); //Son
f.speak(); //fat
}
}
class Father{
int num = 10;
public void print(){
System.out.println("Father");
}
public static void speak(){
System.out.println("fat");
}
}
class Son extends Father {
int num = 5;
public void print(){
System.out.println("Son");
}
public static void speak(){
System.out.println("so");
}
}
多态的好处与应用场景
在方法中，父类对象用作参数，子类方法重写，使得代码的复用性提高
class Demo_Polymorthic3 {
public static void main(String[] args) {
make(new Dog());
make(new Cat());
}
public static void make(Animal a){ //多态常应用于父类作参数,子类方法重写的应用场景
a.eat();
}
}
class Animal{
void eat(){
System.out.println("动物吃饭");
}
}
class Cat extends Animal{
void eat (){
System.out.println("猫吃鱼");
}
void catchmouse(){
System.out.println("捉老鼠");
}
}
在多态的情况下，当父类引用要使用子类特有的方法，要将父类引用强制转换向下转型。以下例子也许可以方便理解和记忆。
class Demo_Polymorthic2 {
public static void main(String[] args) {
Person p = new SuperMan();
System.out.println(p.name); //man
p.谈生意(); //谈几个亿的生意
//p.fly(); //p实际上就是子类向上提升
SuperMan sm = (SuperMan) p; //向下转型
sm.fly();
}
}
class Person{
String name="man";
public void 谈生意(){
System.out.println("谈生意");
}
}
class SuperMan extends Person{
String name = "sup";
public void 谈生意(){
System.out.println("谈几个亿的生意");
}
public void fly(){
System.out.println("去救人");
}
}
在上面的代码中，父类引用p 指向子类对象superman，所以在正常引用下，superman就伪装成普通人person，调用成员变量，当然是用伪装的名字man，而当调用成员方法使，实际上就是superman在“”谈生意“，而不是普通的person,故表现其真实的行为，即superman重写的谈生意()这一方法，调用结果是“谈几个亿的大生意”。当要用到superman特有的方法fly()时，必须向下转型成superman，无法再伪装了。
多态内存图解
抽象类
抽象，即无法具体的，所谓抽象类，即用abstract修饰符修饰的类。
abstract 修饰的方法，没有方法体，如 abstarct eat();
抽象类的成员变量不能抽象
抽象类也有构造方法
抽象类的抽象方法使子类必须重写该方法
抽象类可以有非抽象方法，子类可以不重写该方法
抽象类无法创造对象，无法创造出实例，但可以通过多态引用其子类
class Demo_Abstract {
public static void main(String[] args) {
Animal a = new Cat(); //通过多态来引用抽象类,抽象类本身无法创造实例
}
}
abstract class Animal{
int num1; //抽象类成员变量不能抽象
final int num2 = 10;
Animal(){
System.out.println("抽象类的有参构造"); //抽象类也有构造方法
}
abstract void eat();
public void method(){ //抽象类可以有非抽象方法,子类继承可以不重写
System.out.println("抽象类的非抽象方法");
}
}
class Cat extends Animal{
void eat(){ //抽象类使得子类必须重写其抽象方法
System.out.println("猫吃鱼");
}
}
抽象类规定了子类必须重写的方法，即规定了子类都必须有的方法，且要求其根据实际重写。
接口
广义上的接口，就是向外提供或者说制定的一种规则，如usb接口，规定了生产接口的厂商应该使用的规格，线路的电压等规则。
在JAVA中接口可以说是抽象类进一步抽象，对实现接口的类制定了特定的规则。
接口没有构造方法
接口所有的都是抽象方法，所以实现接口，就是要重写接口所规定的方法
接口所有的变量和方法都是public，因为接口的目的就是表露其规则，让类去实现，所以权限要足够大。
类实现接口用implements，值得注意的是一个类可以实现多个接口，因为接口的方法都是抽象的，没有方法体，不会产生冲突，这弥补了单继承的缺陷。
接口与接口之间可以继承
class Demo_Interface {
public static void main(String[] args) {
InterA a = new Demo();
}
}
//设计理念,抽象类是为了规定共性的东西,接口是为了实现扩展性
interface InterA{
public static final int num = 1; //接口没有构造方法
public abstract void printA(); //接口的方法都是抽象方法
}
interface InterB{
void printB();
}
interface InterC extends InterA,InterB{ //接口可以继承接口,并且是多继承
}
class Demo implements InterC { //类可以实现多个接口
public void printA(){;}
public void printB(){;}
}
关于抽象类和接口的设计理念，抽象类规定了子类共同需要重写的方法，是规定了子类的共性，而接口的多实现，可以使类具有扩展性，如下面的例子
class Demo_Interface2 {
public static void main(String[] args) {
Cat c = new Cat();
c.eat();
JumpCat j = new JumpCat();
j.eat();
j.jump();
}
}
abstract class Animal{
String name;
abstract void eat();
}
interface Jump{
void jump();
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
class JumpCat extends Cat implements Jump{
public void jump(){
System.out.println("跳高");
}
}
在抽象类Animal中定义了抽象方法eat()；因为所有继承他的子类都具有这一行为，必须根据自身重写该方法。而接口Jump定义了jump()；这一抽象方法，不同的类根据自己的需求，是否去实现这一接口，去扩展该类的内容。而且由于接口是多实现的，同一个类可以实现不同的接口，展现于其他类不同的行为。
以上便是今天学习的内容中的要点及最应该注意的地方，其中有什么错误的地方，特别是关于内存的分配方面，由于是自己的理解，可能与实际有偏差，希望读者指出并谅解。
