java基础代码使用

java

1. 文件名需要与类名一致；
2. javac HelloWorld.java和java HelloWorld；

继承

extends：单一继承。一个子类只能有一个父类；
super：对父类成员函数的访问。super.eat();
final：final class A，则A不可被继承；
构造器：子类并不直接继承父类的含参构造器，只能调用；不含参数的则直接继承；

implements：public class C implements A,B{}，其中A，B为interface；

重写和重载

维持返回值和形参，修改内部实现；

//重写 overriding
class Dog{
    public void bark(){
        System.out.println("woof");
    }
}
class Hound extends Dog{
    public void sniff();
    public void bark(){
        System.out.println("bowl");
    }
}
// 重载 overloading
class Dog{
    public void bark(){
        System.out.println("woof ");
    }
    public void bark(int num){
        for(int i=0; i<num; i++){
            System.out.println("woof ");
        }
    }
}

编译阶段只是检查引用类型。运行时，指定对象类型运行对应方法。而重载则是在同一个类中，要求仅为函数名相同。

多态

同一个行为在不同的情境下具有不同的形态和能力。
同样的函数eat和work在调用对象的类型不同时候，执行的代码也不同。

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

java的多态与c++多态不同。对于子类重写的函数：

• c++的对象类型为父类，构造函数为子类时候，调用的函数默认也是父类的实现；(virtual会影响调用规则)
• java对象类型为父类，构造函数为子类时候，调用的函数则默认使用子类的实现；此谓动态多态；

编译时候，使用的类型的方法验证语句，而执行时候使用的则是构造函数对应的函数；

抽象类与抽象方法

不能被直接用于描述对象的类，即不能实例化，只有被继承之后才能使用。关键词abstract；
抽象方法：

1. 仅声明无实现，故无大括号；
2. 仅在抽象类中出现；
3. 子类若使用该抽象方法只能重写实现；

接口

接口规定类要实现的函数。如此中的eat和travel函数。

/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}
/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
   public void eat(){ System.out.println("Mammal eats"); } 
   public void travel(){ System.out.println("Mammal travels"); } 
   public int noOfLegs(){ return 0; }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

接口没有构造方法，不能实例化对象；接口不包含成员变量，其所有方法必抽象；接口用以被类实现，支持多继承；
接口中的成员变量只能是public static final类型，其方法均为隐式抽象，即默认抽象，声明时候不需要abstract；
标记接口：没有任何方法和属性的接口，用以表明它的类属于一个特定的类型。

package

组织功能相似或相关的类或接口，方便类的查找和使用。

附录

区别于C++

1. 放弃操作符重载，不使用指针而是引用，自动废料收集；
2. 类单继承，接口多继承；
3. 支持Internet应用开发；
4. java => 字节码 => 解释执行； 高性能解释性语言
5. 默认使用动态多态，即子类重写的函数调用时候以调用该函数的对象性质为基准进行调用；
   部分代码来自菜鸟教程:https://www.runoob.com/java/