Day17测试及知识整理

构造方法

构造方法无返回类型值[无void],且名称必须与类名相同

this()

调用自己的[本类]无参数构造函数；
实现构造方法的复用

this(int m):调用自己的[本类]有一个参数的构造函数
以此类推…

一般放在构造函数首行
不能同一个构造器中出现两个this()
this需要放构造函数首行

存在编译错误
public M(int m,int n){
this();
this(3);}

class M{
    //无参构造
//    public M(){
//        this();
      //this();调用自身无参数构造,不能放入无参构造函数中调用
//    }
    public M(){

    }

    public M(int m){
        this(); //必须要有对应的构造函数存在，才能调用
    }

    public M(int m,int n){
//        this();  //编译错误不同同时出现两个
        this(3);
    }
}

super()

子类构造前需要先构造父类

子类构造方法中，首行必须是super()，即调用父类无参数构造方法，也可调父类有参构造方法

子类构造方法没写super()时，系统默认调用父类无参构造，这时必须保证父类有无参构造方法

但必须写在构造方法首行

class N extends M{
    public N(){
        //未写super(),系统默认调用父类无参构造
    }
    public N(int n){
        super(5);//子类构造前需要先构造父类
//        this(); //编译错误 super()与this()不能同时出现在一个构造器中
    }
      public N(int a,int b){
      //没有写super(),系统默认调用父类无参构造
        this(a);
    }
}

super()与this()均要放在构造函数的首行，否则不能同时在一个构造函数中使用

重载

只有方法名相同，形参列表不同[形参参数个数不同 或 形参参数数据类型不同]，与返回类型值、返回值无关

方法返回值类型、修饰符 可以相同，也可以不同

仅有返回类型值不同，不足以区分两个重载

void sayHi(){ System.out.println(“HHH”); }
int sayHi(){ System.out.println(“HHH”); return 0; }
编译错误，仅有返回类型不同，不足以区分两个重载

//重载: 只有方法名相同,形参列表不同[参数个数不同 参数数据类型不同],与返回值类型无关;
//方法类型、修饰符可以相同，也可以不同
//仅有返回类型不同，不足以区分两个重载
public class Demo1Override {
    void sayHi(){
        System.out.println("HHH");
    }
    //编译错误，仅有返回类型不同，不足以区分两个重载
//    int sayHi(){
//        System.out.println("HHH");
//        return 0;
//    }
    //只有方法名相同,形参列表不同[参数个数不同 参数数据类型不同]
    //只有方法名相同,参数数据类型不同
    void sayHi(int a){
        System.out.println("HHH");
    }
    //编译错误，仅有返回类型不同，不足以区分两个重载
//    int sayHi(int a){
//        System.out.println("HHH");
//        return 0;
//    }
    int sayHi(String a){
        System.out.println("HHH");
        return 0;
    }
    //只有方法名相同,参数个数不同
    int sayHi(String a,String b){
        System.out.println("HHH");
        return 0;
    }
}

new 类 决定对象的数据类型

new 类

类是谁，调用的就是该类中的方法

new 类 决定了对象的数据类型
即使进行强转 本质还是看new的什么类型

A a1=(A)new B();
System.out.println(a1.getClass());//class day6.B
即使强转为A类型 本质对象还是B类，因此调用B类的go()

class A{
    void go(){
        System.out.println("这是父类");
    }
}
class B extends A{
    void go(){
        System.out.println("这是子类");
    }
}

public class Demo2Extends {
    public static void main(String[] args) {
        //new的类是谁，调用的就是该类中的方法
        A a=new A();
        a.go(); //这是父类

        A a1=(A)new B();
        //new 类 决定了对象的数据类型 
        //即使进行强转 本质还是看new的什么类型 是什么类
        System.out.println(a1.getClass());//class day6.B
        // 即使强转为A类型 本质对象还是B类，因此调用B类的go()
        a1.go(); //这是子类

        A a2=new B();
        a2.go();//这是子类

        B b=new B();
        b.go();//这是子类

        //B b1=new A(); 
        //编译错误 父类创建的对象不能赋值给子类引用类型的变量

    }

}

java源文件编译与运行

Java中的编译和运行过程可以分为两个阶段：

第一个阶段是编译阶段， javac命令 将.java源文件编译成.class字节码文件

第二个阶段是运行阶段， java命令 将.class字节码文件加载到内存，并在JVM中进行解释或优化

能被java.exe成功运行的java class文件必须有main()方法

判断以下正误，错在哪

能被java.exe成功运行的java class文件必须有main()方法

Java源码直接运行在JVM中，JVM会对源码进行编译和运行

Java源码编译完生成平台直接可运行的二进制文件

class文件是字节码，字节码是和机器相关的可运行代码

Integer 与 int

Integer 自动装箱的数值范围在 -127至128中

常量值超出范围，则需要开辟新空间来存储

new Integer()均是堆内存中开辟新空间

int类型 与 Integer类型比较 == 或 equal将Integer拆箱, 再比较值
若重写过equal()方法，一般比数值

public class Demo1Learn {
    public static void main(String[] args) {
        Integer a1=17,a2=17;
        Integer b1=2017,b2=2017;
        Integer c1=new Integer(17);
        Integer c2=new Integer(17);
        Integer d1=new Integer(2017);
        Integer d3=new Integer(2017);
        int d2=2017;
        int e1=17;
        System.out.println(a1==a2);//true

        System.out.println(b1==b2);//false
        //常量值超出范围，则需要开辟新空间来存储  则开辟两个新空间
        System.out.println(b1.equals(b2));//true
        // equals()方法 只比数值

        System.out.println(c1==c2);//false
        //new创建了两个空间
        System.out.println(c1.equals(c2));
        // equals()方法 只比数值

        System.out.println(a1==c1);//false
        //两个空间地址 不相等
        System.out.println(a1.equals(c1));//true
        // equals()方法 只比数值

        System.out.println(d1==d3);//false 两个空间位置不想等
        System.out.println(d1.equals(d3));//true

        //int类型 与 Integer类型比较 == 或 equal
        //将Integer拆箱, 再比较值
        System.out.println(d1==d2);//true
        System.out.println(e1==a1);//true
        System.out.println(e1==c1);//true
        System.out.println(d1.equals(d2));//true
        System.out.println(a1.equals(e1));//true
        System.out.println(c1.equals(c1));//true
        //int类型[基本数据类型] 无equals()方法
        //Integer 自动装箱的数值范围在 -127至128中
        //常量值超出范围，则需要开辟新空间来存储
        //new Integer() 均是堆内存中开辟新空间
        //int类型 与 Integer类型比较 == 或 equal将Integer拆箱, 再比较值
    }
}