作者: hey_leex | 来源:发表于2018-01-05 17:02 被阅读0次

    成员变量和局部变量的区别?

    1. 在类中的位置不同

      • 成员变量:在类中方法外

      • 局部变量:在方法定义中或者方法声明上

    2. 在内存中的位置不同

      • 成员变量:在堆内存

      • 局部变量:在栈内存

    3. 生命周期不同

      • 成员变量:随着对象的创建而存在,随着对象的消失而消失

      • 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失

    4. 初始化值不同

      • 成员变量:有默认初始化值

      • 局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。

    5. 注意事项:

      • 局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。

    方法

    方法就是函数,function,是为了完成特定功能的代码块

    修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2…) {
            函数体;
            return 返回值;
    }
    
    1. 定义函数可以将功能代码进行封装
    2. 便于对该功能进行复用
    3. 函数只有被调用才会被执行

      (当函数被调用的时候,jvm虚拟机会在内存中给该函数分配一块内存空间,该内存空间里面可以定义该函数所用到的一些变量,当方法执行完毕之后,该内存空间会被释放掉。)调用完成,函数执行完毕。
    4. 函数的出现提高了代码的复用性
    5. 对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的return语句如果在最后一行可以省略不写。

    注意:

    1. 调用方法时可以不接受方法返回的值,且不会报错
    2. 函数中只能调用函数,不可以在函数内部定义函数。

    方法重载

    1. 同一个类中,允许存在一个以上的同名的方法,参数个数,参数类型不同
    2. 与返回值类型无关,只看方法名和参数列表
    3. 虚拟机通过参数列表的不同来区分同名方法
    4.  public void repeatName () {
       
       }
       
       public void repeatName (int i) {
           
       }
       
       public void repeatName (double i) {
           
       }
      

    形参

    1. 基本类型:形式参数的改变不影响实际参数

    2. 引用类型:传入一个类的对象,形参是该对象的一个引用,形式参数的改变直接影响实际参数

      1. 类名:需要的是该类的对象
      2. 抽象类:需要的是该抽象的类子类对象,用具体子类实现
      3. 接口:需要的是该接口的实现类对象,用具体子类实现
    3. String是引用类型,但不能进行地址传递


        //抽象类
        abstract class Person {
            public abstract void study();
        }
    
        class PersonDemo {
            public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
                p.study();
            }
        }
        
        //定义一个具体的学生类
        class Student extends Person {
            public void study() {
                System.out.println("Good Good Study,Day Day Up");
            }
        }
        
        class PersonTest {
            public static void main(String[] args) {
                //目前是没有办法的使用的
                //因为抽象类没有对应的具体类
                //那么,我们就应该先定义一个具体类
                //需求:我要使用PersonDemo类中的method()方法
                PersonDemo pd = new PersonDemo();
                Person p = new Student();
                pd.method(p);
            }
        }
    
    
        //接口
        //定义一个爱好的接口
        interface Love {
            public abstract void love();
        }
        
        class LoveDemo {
            public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
                l.love();
            }
        }
        
        //定义具体类实现接口
        class Teacher implements Love {
            public void love() {
                System.out.println("老师爱学生,爱Java,爱林青霞");
            }
        }
        
        class TeacherTest {
            public static void main(String[] args) {
                //需求:我要测试LoveDemo类中的love()方法
                LoveDemo ld = new LoveDemo();
                Love l = new Teacher();
                ld.method(l);
            }
        }
    

    返回值

    引用类型:

    1. 类:返回的是该类的对象
    2. 抽象类:返回的是该抽象类的子类对象
    3. 接口:返回的是该接口的实现类的对象
    - 类
    
            class Student {
                public void study() {
                    System.out.println("Good Good Study,Day Day Up");
                }
            }
    
            class StudentDemo {
                public Student getStudent() {
                    return new Student();
                }
            }
    
    
    - 抽象类
    
            abstract class Person {
                public abstract void study();
            }
            class PersonDemo {
                public Person getPerson() {
                    //Person p = new Student();
                    //return p;
                    
                    return new Student();
                }
            }
            class Student extends Person {
                public void study() {
                    System.out.println("Good Good Study,Day Day Up");
                }
            }
    
    
    - 接口
    
            interface Love {
                public abstract void love();
            }
            class LoveDemo {
                public Love getLove() {
                    //Love l = new Teacher();
                    //return l;
                    
                    return new Teacher();
                }
            }
            //定义具体类实现接口
            class Teacher implements Love {
                public void love() {
                    System.out.println("老师爱学生,爱Java,爱林青霞");
                }
            } 
    

    构造方法

    给对象的属性赋初值

    1. 构造方法格式
      • 方法名与类名相同

      • 没有返回值类型,连void都没有

      • 没有具体的返回值

          public Student(){
              
          }
          public Student(String name1, int sge) {         //构造函数可以重载
              this.name1 = name1;
              this.sge = sge;
          }   
        
    2. 默认构造:建议自己给出无参构造
      • 如果你不提供构造方法,系统会给出默认构造方法
      • 如果你提供了构造方法,系统将不再提供

    创建对象

    Student s = new Student();
    

    加载过程

    1. 加载Student.class文件进内存
    2. 在栈内存为s开辟空间
    3. 在堆内存为学生对象开辟空间
    4. 对学生对象的成员变量进行默认初始化
    5. 对学生对象的成员变量进行显示初始化
    6. 通过构造方法对学生对象的成员变量赋值
    7. 学生对象初始化完毕,把对象地址赋值给s变量

    匿名对象

    匿名对象:就是没有名字的对象。

    匿名对象的应用场景:

    1. 调用方法,仅仅只调用一次的时候。
      • 好处:匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
    2. 匿名对象可以作为实际参数传递

    Class s = new Class();
    s.method();
    
    new Class().method();
    new Class().method(new Class());

    相关文章

      网友评论

          本文标题:

          本文链接:https://www.haomeiwen.com/subject/kuysnxtx.html