亲宝软件园·资讯

展开

Java笔记

开心burukku 人气:0

实例方法&实例变量

实例方法

方法不带'static'关键字,为实例方法,实例方法必须先创建对象,通过“引用.”点方式调用。

注:

·带static的方法为静态方法,通过“类名.”的方式访问,也可以通过“引用.”的方式进行访问,但会出现警告,当对象为null时,并不会出现空指针异常错误,因为并不需要对象的存在;

·类体中定义的变量,为实例变量;方法体内定义的变量为局部变量,在栈内存中存储;

·实例变量存储在堆内存中的对象中;

·堆内存中存储的对象,每当创建一个新对象,即“new”出一个对象时,存储在堆内存中。

 

代码示例:

package com.beijing.javase.test002;

public class ThisTest {

    public static void main(String[] args) {
        
        //调用doSome方法
        doSome();
        
        //调用doOther方法
        //doOther(); //直接调用doOther方法时,没有对象,编译报错
        
        //需要通过创建对象,进行“引用.”的方式来调用实例方法
        ThisTest t = new ThisTest();
        t.doOther();
        
    }

    public static void doSome() {
        System.out.println("do Some");
    }
    
    public void doOther() {
        System.out.println("do Other");
    }
}

 就上述代码而言,当调用实例方法时,完整的写法是

this.doOther();

this指的是当前变量,一般情况下是省略的。

this在static方法里时,是不存在的。

那个对象调用构造方法时,this就是谁。

上述直接调用doOther方法时,由于当前方法体内,并没有创建对象,所以编译报错。

由此看来,在static方法中,调用实例方法时,需要创建对象,不能用“this.”的方式来访问。

在静态方法中,无法调用this,因为静态方法的执行,没有对象的参与,是直接采用“类名.”的方式,所以不存在this。

 

实例变量

当在类体中定义了一个非static变量时,无法在带有static的方法中直接调用,因为再类体中定义的为实例变量,需要通过“引用.”的方式来调用。即先创建一个对象,来进行引用;实例变量是对象级别的;

代码示例:

package com.beijing.javase.test001;

public class ThisTest {

    //类体中定义了一个sum变量
    int sum = 10;
    
    public static void main(String[] args) {
        
        //编译报错
        //System.out.println(sum); 
        
        ThisTest t = new ThisTest();
        System.out.println(t.sum);
    }

}

最终结论:在带有static的方法当中不能直接访问实例变量和实例方法。因为实例变量和实例方法都需要对象的存在。

而static的方法中是没有this的。也就是说当前对象是不存在的,自然也就无法访问当前对象的实例方法及实例变量。

 

构造方法

在构造方法中,通过当前的构造方法调用其他的构造方法【语法格式:this(实参);】

在一个类 文件中,当一个无参构造方法用this调用有参构造方法的时候,this必须在第一行(由此说明,只能有一句)


静态方法&静态变量(static关键字)

静态变量

带有static关键字的变量,为静态变量;在类加载的时候初始化,不需要创建对象来开辟内存;静态变量的内存开辟在方法区内存当中;调用的时候,不需要创建对象,采用“类名.”的方式来调用静态变量。

多个对象具有同一变量的时候,适合创建静态变量,节省内存空间。

当所有对象具有这个属性,但是这个属性根据对象的变化而变化,适合采用实例变量,存储在堆内存创建的对象中。

当所有对象具有这个属性,并且所有的对象具有的这个属性都是相同的,适合采用静态变量,存储在方法区内存中。

所有的静态变量都可以采用“类名.”也可以采用“引用.”的方式,会出现警告,当引用是null时,也不会出现空指针错误,因为是不依赖于对象的。

static修饰的所有元素都是类级别的特征,与具体的对象无关。

static关键字

static静态代码块,在类加载的时候执行,且执行一次;静态代码块可以有多个,按照顺序执行;位于类体中;main方法执行前执行;

代码格式:

static {
    java代码
}

实例代码块

也存在于类体中,初始化对象的时候执行,可有多个,按照顺序执行,位于类体中;在new一个对象的时候会执行

public class ThisTest {
    //实例代码块
        {
               java语句    
        }
    public static void main(String[] args) {
    }
}

 静态方法

带有static修饰的方法为静态方法,调用静态方法时,采用“类名.”的方式调用;静态方法无妨直接访问实例变量、调用实例方法,需采用“引用.”的方式;

方法描述的是动作,当所有的对象执行这个动作的时候,最终产生影响是一样的,那么这个动作就不属于某一个对象的动作了,可以提升为这个类级别的动作,提供模板级别的动作,个人感觉与静态变量的使用原因相同

在静态方法中,无法调用this,因为静态方法的执行,没有对象的参与,是直接采用“类名.”的方式,所以不存在this。

 


 

Java代码总结解析(调用静动态方法变量)

目前理解的Java代码总结

//此处的“Test”与文件名相同,例如本文件名就为Test.java
public class Test {

    静态代码块; //类加载的时候执行
    static {
        *****;
    }
    
    实例代码块; //初始化对象的时候开始执行
    {
        ****;
    }
    
    静态变量; //通过“类名.变量名”的方式调用
    static int i = 10;
    
    实例变量; //通过“引用.变量名”的方式调用,即先new一个对象,通过“对象.”的方式调用
    int j = 20;
    
    构造方法; //也叫构造函数,构造方法分为有参构造和无参构造,默认有一个无参构造,也可以手动创建无参构造方法
    //方法名需同类名相同
    
    //无参
    public 类名() {
    }
    
    //有参
    public 类名(int a,String b) {
        System.out.println(a,b);
    }
    
    
    静态方法; //通过“类名.方法”调用,当与静态方法处于一个类文件下时,“类名.”可以省略
    
    public static void sum(){
        *****;
    }
    
    实例方法; //通过“引用.方法”调用,即先new一个对象,通过“对象.”的方式调用
    public void sum2(){
        *******;
    }
    
    例:
    public static void main(String[] args){
        //调用上文中的静态方法
        //完整写法
        Test.sum();
        //省略写法
        sum();
        
        //访问上文中的静态变量
        //完整写法
        System.out.println(Test.i);
        //省略写法,因为处于同一类中,所以“类名.”可以省略
        System.out.println(i);
        
        
        //调用上文中的实例方法,需首先创建对象,通过“引用.”的方式进行访问
        Test t = new Test();
        t.sum2();

     //调用实例变量
     System.out.println(t.j);  

}
}

 


 

继承(extends)

例:A类继承B类    public class A extends B

B类为父类、基类、超类、superclass

A类为子类、派生类、subclass

在继承的过程中,私有的不支持继承,构造方法不支持继承,其余的可以继承;继承只能单继承,但是可以间接继承;

方法的覆盖

当父类中的方法无法满足子类中的使用,需要重写,需要到方法的覆盖;

覆盖的要求:

  ·方法重写的时候,具有继承关系的父子类之间;

  ·方法重写的时候,返回值的类型、方法名、形参列表相同;

  ·方法重写的时候,不能比父类中方法的访问权限低(public > private);

  ·方法重写的时候,能抛出的异常不能更多,只能更少;

即满足以上条件时,当子类与父类中具有相同的方法时,执行的是子类当中的方法,因为视于方法被覆盖;

注:

  私有方法不被继承,所以不能覆盖;

  构造方法不被继承,所以不能覆盖;

  静态方法不存在覆盖;

  覆盖只针对方法,不谈及属性;

 

 

 


 

加载全部内容

相关教程
猜你喜欢
用户评论