Java基础知识7

类和对象_2

1.Java类中方法的表现形式及其基本特征？

    Java类中方法是为了描述具有共同性质的一组数物的基本功能/行为。

  1.1.Java类中方法的表现形式

    1.实例方法格式

        访问限制修饰符  方法的返回值数据类型  方法的名称（参数列表）{方法体}

        1)访问限制修饰符---public  缺省的

        2)方法的返回值数据类型

            返回值-----方法执行结果

            数据类型---基本数据类型【复合数据类型】

            有返回值---方法体中的最后一句话是“return”,方法的返回值数据类型一定是结果值的具体数据类型

            没有返回值---方法体中的没有“return”,方法的返回值数据类型void代替。

        3)方法的名称---合法的标识符【首字母小写，从第二个单词开始首字母大写】

        4)参数列表

            参数----引入本方法以外的数据进入本方法进行运算【找帮手】局部变量

            列表----可以有多个

            没有参数的时候--（）中的内容是空的

        5)方法体--方法的身体【具体执行代码】

例如：

public class Tect1{
//1.实例方法
        //1.没有返回值，没有参数的实例方法
               public void method1(){

                   }
        //2.有返回值【int】，没有参数的实例方法
               public  int  method2(){
                   return 0;//返回的时最后的结果
                }
        //3.没有返回值，有一个int参数的实例方法
              public void method3(int num){
                  
                     }
        //4.有返回值片【String】，有一个int参数的方法,一个String参数的实例方法
              public String method4(int num1,String str){
                                 return  "hello";
                      }
   
}

    2.静态方法格式

        实例方法的访问限制修饰符后面加上static关键字的方法就是静态方法【类方法】

        没有static关键字的方法就是实例方法

例如：

public class Tect2{
//2.静态方法
        //1.没有返回值，没有参数的静态方法
               public static void method1(){
   
                 }
        //2.有返回值【int】，没有参数的静态方法
               public static int method2(){
                         return  0;
                 }
        //3.没有返回值，有一个参数int的静态方法
              public static void method3(int  num){
           
                 }
        //4.有返回值[String]，有一个int参数，有一个String参数的静态方法
               public static String method4(int  num,String  str){ 
                            return  "Hello";
                     }
     
}

    3.构造方法格式

        实例方法格式中去掉方法的返回值数据类型，方法的名称是类名这种方法就叫构造方法。

例如：

public class Tect3{
//3.构造方法
        //1.没有参数的构造方法【无参构造方法】
                public Tect3(){
           
                 }
        //2.有一个int参数的构造方法
                  public Tect3(int  num){
          
                     }
        //3.有多个参数的构造方法
                public Tect3(int num,String str){
        
                   }
}

        构造方法作用就是将来为了创建对象用的。

        当一个类创建好以后，会有一个默认的无参数构造方法存在，只是没有显式写出罢了。

                当这个类中出现一个有参数的构造方法时，我们就需要将这个默认的无参数构造方法显式写出,如果没有

        显式写出这个默认的无参数构造方法，那么这个默认的无参数构造方法将会被有参数的构造方法覆盖。

public  class  Student{
//存在一个默认的无参数构造方法
//当有参数的构造方法时，无参构造方法要写出来，否则会被覆盖
public Student(){}
public  Student(String name){}  
}

2.什么是方法重载？

    在同一个类中方法的名称相同，参数不一样，这种现象就叫方法重载。

    注意：方法重载与方法的返回值类型没有关系

例如:

public class Tect4{
//方法重载
//在同一个类中，方法的名称相同，参数不同就是方法重载
//注意：方法重载与方法的返回值类型没有关系
//同一个类中，方法的名称相同，参数不同
//参数不同：1.个数不同  2.数据类型不同
        //1.实例方法重载
              public void shiliMethod(){}
              public void shiliMethod(int num){}
              public void shiliMethod(String str){}
             //与返回值的数据类型无关，所以当参数的数据类型相同时，就会报错
             // public String shiliMethod(String str){}
               public String shiliMethod(String str,String str2){
                        return  "hello";
                           }
            
        //2.静态方法重载
              public  static void staticMethod(){}
              public  static void staticMethod(int num){}
              public  static void staticMethod(String str){}
              public  static String staticMethod(String str,String str2){
                        return  "hello";
                           }
        //3.构造方法重载
             public  Tect4(){}
              public  Tect4(int num){}
              public  Tect4(String str){}
              public  Tect4(String str,String str2){}
  
}

3.同一个Java类中方法与变量的调用关系？

  1.在同一个类中，构造方法中可以访问实例变量/类变量/局部变量

      1)构造方法中访问实例变量默认this.实例变量,this可以被省略。

      2)构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略

      3)构造方法中访问局部变量直接变量名称

  2.在同一个类中，实例方法中可以访问实例变量/类变量/局部变量

      1)实例方法中访问实例变量默认this.实例变量,this可以被省略。

      2)实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略

      3)实例方法中访问局部变量直接变量名称

  3.在同一个类中，静态方法中可以访问类变量/局部变量，不可以访问实例变量

      1)静态方法中访问类变量默认类名.实例变量,类名可以被省略

      2)静态方法中不能有this

      3)静态方法中访问局部变量直接变量名称

例如：

//方法调变量
public class Tect5{
         public int tesid=1001;//实例变量
         public static String testname="张三";//静态成员变量【类变量】
        //同一个类中方法与变量的关系
        //1.只能在方法中调用变量变量，不能用变量调用方法
//1.构造方法中调用本类变量
        //构造方法中可以访问实例变量，默认this.实例变量，也可以省略this.
        //构造方法中可以类变量，默认类名.类变量，也可以this.类变量，可以省略类名.，this.
        //构造方法中可以访问局部变量，直接局部变量的名称                  
       
      public  Tect5(){
        char val='G';
      System.out.println("构造方法中调用实例变量默认this.tesid=="+this.tesid); 
      System.out.println("构造方法中调用实例变量tesid=="+tesid); 
      System.out.println("构造方法中调用静态变量默认类名Tect5.testname=="+Tect5.testname); 
      System.out.println("构造方法中调用静态变量this.testname=="+this.testname); 
      System.out.println("构造方法中调用静态变量testname=="+testname); 
      System.out.println("构造方法中调用局部变量val=="+val);         
                 }
           
//2.实例方法中调用本类变量
        //实例方法中可以访问实例变量，默认this.实例变量，也可以省略this.
        //实例方法中可以类变量，默认类名.类变量，也可以this.类变量，可以省略类名.，this.
        //实例方法中可以访问局部变量，直接局部变量的名称
      public void shiliMethod(){
         char val='G';
      System.out.println("实例方法中调用实例变量默认this.tesid=="+this.tesid); 
      System.out.println("实例方法中调用实例变量tesid=="+tesid); 
      System.out.println("实例方法中调用静态变量默认类名Tect5.testname=="+Tect5.testname); 
      System.out.println("实例方法中调用静态变量this.testname=="+this.testname); 
      System.out.println("实例方法中调用静态变量testname=="+testname); 
      System.out.println("实例方法中调用局部变量val=="+val);          
System.out.println("================================");         
                 }

//3.静态方法中调用本类变量
        //静态方法中绝对不能用this
        //静态方法中不能访问实例变量
        //静态方法中可以访问类变量，默认类名.类变量,可以省略类名.
        //静态方法中可以本方法的局部变量，直接使用局部变量名称
      public static void staticMethod(){
        char val='G';
    //静态方法中不能调用实例变量
    //System.out.println("静态方法中调用实例变量默认this.testid=="+this.testid);
    //静态方法中不能调用实例变量
    //System.out.println("静态方法中调用实例变量testid=="+testid);
      System.out.println("静态方法中调用静态变量默认类名Tect5.testname=="+Tect5.testname); 
    //无法从静态上下文中引用非静态 变量 this
    //System.out.println("静态方法中调用静态变量this.testname=="+this.testname); 
      System.out.println("静态方法中调用类变量testname=="+testname);
      System.out.println("静态方法中调用局部变量val=="+val);
       }
}

测试类：

public class TectMain{
         public static void main(String args[]){
            //测试构造方法
             Tect5 t5=new Tect5();
            //测试实例方法
              t5.shiliMethod();
            //测试静态方法
              t5.staticMethod();
               
    }
} 

4.同一个Java类中方法与方法的调用关系？

  1.在同一个类中，构造方法中可以访问其他的构造方法/实例方法/类方法

      1)构造方法中访问其他的构造方法new  其他的构造方法;

      2)构造方法中访问实例方法默认this.实例方法,this可以被省略

      3)构造方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略

  2.在同一个类中，实例方法中可以访问构造方法/其他实例方法/类方法

      1)实例方法中访问构造方法默认new  构造方法

      2)实例方法中访问其他实例方法默认this.其他实例方法,this可以被省略

      3)实例方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略

  3.在同一个类中，静态方法中可以访问构造方法/其他的静态方法，不可以访问实例方法

      1)静态方法中访问构造方法new  构造方法

      2)静态方法中不能有this

      3)静态方法中访问类方法默认类名.类方法,类名可以省略

例如：

public class Tect6{
        //同一个类中，方法与方法的关系
        //1.构造方法访问其他的方法，
        //构造方法可以访问其他的构造方法，new  构造方法名称
        //构造方法可以访问实例方法，默认this.实例方法名称，this可以省略
        //构造方法可以访问类方法，默认类名.类方法名称，也可以this.类方法名称，类名.this.可以省略
          
    public Tect6(){
      System.out.println("构造方法访问其他方法");
               new Tect6("zhangsan");
               this.shiliMethod("西安");
               shiliMethod("西安");
               Tect6.staticMethod("大明");
               this.staticMethod("大明");
               staticMethod("大明");
System.out.println("======================================");
             }
             public Tect6(String name){
              System.out.println("有参数的构造方法，参数name=="+name);
             }
        //2.实例方法访问其他的方法
        //实例方法可以访问构造方法，new  构造方法名称
        //实例方法可以访问其他实例方法，默认this.实例方法名称，this可以省略
        //实例方法可以访问静态方法，默认类名.类方法名称，也可以this.类方法名称，类名.this.可以省略
              public void shiliMethod(){
                    System.out.println("实例方法访问其他方法");
                       new Tect6("李四");
                       this.shiliMethod("北京");
                       shiliMethod("北京");
                       Tect6.staticMethod("大汉");
                       this.staticMethod("大汉");
                       staticMethod("大汉");
System.out.println("======================================");
              }
               public void shiliMethod(String address){
                 System.out.println("有参数的实例方法，参数address=="+address);
              }
        //3.静态方法
        //静态方法中绝对不能有this
        //静态方法可以访问构造方法，new  构造方法
        //静态方法不可以访问实例方法
        //静态方法可以访问其他类方法，默认类名.类方法，类名.可以省略
              public static void staticMethod(){
                    System.out.println("静态方法访问其他方法");
                       new Tect6("zhaosi");
                     //错误: 无法从静态上下文中引用非静态 方法 shiliMethod(String)
                     //this.shiliMethod("南京");
                     //错误: 无法从静态上下文中引用非静态 方法 shiliMethod(String)
                     //shiliMethod("南京");
                       Tect6.staticMethod("大秦");
                     //无法从静态上下文中引用非静态 变量 this
                     //this.staticMethod("大秦");
                       staticMethod("大秦");
               }
              public static void staticMethod(String val){
                System.out.println("有参数的静态方法，参数val=="+val);
               }
}

测试类：

public class TectMain1{
         public static void main(String args[]){
            //测试构造方法
            Tect6 t6=new Tect6();
            //测试实例方法
              t6.shiliMethod();
            //测试静态方法
              t6.staticMethod();
               
    }
} 

5.为什么静态方法中不可以访问实例元素？

    静态方法内存分配时机早于实例元素的内存分配时机，静态方法访问实例元素的时候，实例元素是不存在。

6.为什么静态方法可以可以访问构造方法，不能访问实例元素？

    构造方法是特殊的方法，是类初始化的入口，构造方法不需要实例化对象就能使用

            jvm中有类加载器，第一次加载类时构造方法也会随着类一起加载分配内存空间，jvm中的类加载器第一次加载类时会执行类中

    的static域，jvm会专门划分一个内存区域给static程序块，可称为静态区，属于static这个类；而this指针指向的是类的对象，在实例

    化对象(new)时jvm会在堆区分配内存给一个具体对象，this指针指向的是这个对象，而类中的static域始终是在静态区分配内存 this

    指向了堆区所以不能调用。所以静态方法可以访问构造方法，并且不能使用this。

7.类的结构