JAVA学习记录day3

今天的主要内容是构造方法，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()；这一抽象方法，不同的类根据自己的需求，是否去实现这一接口，去扩展该类的内容。而且由于接口是多实现的，同一个类可以实现不同的接口，展现于其他类不同的行为。

---

以上便是今天学习的内容中的要点及最应该注意的地方，其中有什么错误的地方，特别是关于内存的分配方面，由于是自己的理解，可能与实际有偏差，希望读者指出并谅解。