属性:

类的设计中,两个重要结构之一:属性  

  对比:属性 vs 局部变量

  1.相同点:
  * 1.1 定义变量的格式:数据类型 变量名 = 变量值
  * 1.2 先声明,后使用
  * 1.3 变量都其对应的作用域


  2.不同点:
  2.1 在类中声明的位置的不同
  * 属性:直接定义在类的一对{}内
  * 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
  *
  * 2.2 关于权限修饰符的不同
  * 属性:可以在声明属性时,指明其权限,使用权限修饰符。
  * 常用的权限修饰符:private、public、缺省、protected --->封装性
  * 目前,大家声明属性时,都使用缺省就可以了。
  * 局部变量:不可以使用权限修饰符。
  *
  * 2.3 默认初始化值的情况:
  * 属性:类的属性,根据其类型,都默认初始化值。
  * 整型(byte、short、int、long:0)
  * 浮点型(float、double:0.0)
  * 字符型(char:0 (或'\u0000'))
  * 布尔型(boolean:false)
  *
  * 引用数据类型(类、数组、接口:null)
  *
  * 局部变量:没默认初始化值。
  * 意味着,我们在调用局部变量之前,一定要显式赋值。
  * 特别地:形参在调用时,我们赋值即可。
  *
  * 2.4 在内存中加载的位置:
  * 属性:加载到堆空间中 (非static)
  * 局部变量:加载到栈空间

  

  补充:回顾变量的分类:
  方式一:按照数据类型:

  

   方式二:按照在类中声明的位置:

  

 方法:  

  类的设计中,两个重要结构之二:方法
  方法:描述类应该具的功能。
  

  * 比如:Math类:sqrt()\random() \... 
  * Scanner类:nextXxx() ... 
  * Arrays类:sort() \ binarySearch() \ toString() \ equals() \ ... 
  *  
  * 1.举例: 
  * public void eat(){} 
  * public void sleep(int hour){} 
  * public String getName(){} 
  * public String getNation(String nation){} 
  * 


  * 2. 方法的声明:权限修饰符 返回值类型 方法名(形参列表){
  * 方法体
  * }
  * 注意:static、final、abstract 来修饰的方法,后面再讲。
  *
  * 3. 说明:
  * 3.1 关于权限修饰符:默认方法的权限修饰符先都使用public
  * Java规定的4种权限修饰符:private、public、缺省、protected -->封装性再细说
  *
  * 3.2 返回值类型: 返回值 vs 没返回值
  * 3.2.1 如果方法返回值,则必须在方法声明时,指定返回值的类型。同时,方法中,需要使用
  * return关键字来返回指定类型的变量或常量:“return 数据”。
  * 如果方法没返回值,则方法声明时,使用void来表示。通常,没返回值的方法中,就不需要
  * 使用return.但是,如果使用的话,只能“return;”表示结束此方法的意思。
  *
  * 3.2.2 我们定义方法该不该返回值?
  * ① 题目要求
  * ② 凭经验:具体问题具体分析
  *
  * 3.3 方法名:属于标识符,遵循标识符的规则和规范,“见名知意”
  *
  * 3.4 形参列表: 方法可以声明0个,1个,或多个形参。
  * 3.4.1 格式:数据类型1 形参1,数据类型2 形参2,...
  *
  * 3.4.2 我们定义方法时,该不该定义形参?
  * ① 题目要求
  * ② 凭经验:具体问题具体分析
  *
  * 3.5 方法体:方法功能的体现。

  4. 方法的使用中,可以调用当前类的属性或方法
  * 特殊的:方法A中又调用了方法A:递归方法。
  * 方法中,不可以定义方法。 

return关键字:
  1.使用范围:使用在方法体中
  2.作用:① 结束方法
  * ② 针对于返回值类型的方法,使用"return 数据"方法返回所要的数据。
  3.注意点:return关键字后面不可以声明执行语句。\

方法的重载 

  1.方法的重载的概念
  定义:在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
  *
  总结:"两同一不同":同一个类、相同方法名
  参数列表不同:参数个数不同,参数类型不同

  2.构成重载的举例:

  举例一:Arrays类中重载的sort() / binarySearch();PrintStream中的println()

  

举例二: 
//如下的4个方法构成了重载 
    public void getSum(int i,int j){ 
        System.out.println("1"); 
    } 
     
    public void getSum(double d1,double d2){ 
        System.out.println("2"); 
    } 
     
    public void getSum(String s ,int i){ 
        System.out.println("3"); 
    } 
     
    public void getSum(int i,String s){ 
        System.out.println("4"); 
    } 
    
不构成重载的举例: 
    //如下的3个方法不能与上述4个方法构成重载 
//    public int getSum(int i,int j){ 
//        return 0; 
//    } 
     
//    public void getSum(int m,int n){ 
//         
//    } 
     
//    private void getSum(int i,int j){ 
//         
//    }

  3. 如何判断是否构成方法的重载?
  严格按照定义判断:两同一不同。
  跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系!

  4.如何确定类中某一个方法的调用:

  方法名 ---> 参数列表  

面试题:方法的重载与重写的区别? 
 
throws\throw 
String\StringBuffer\StringBuilder 
Collection\Collections 
final\finally\finalize 
... 
 
抽象类、接口 
sleep() / wait()

可变个数形参的方法

1.使用说明:
  * 1.jdk 5.0新增的内容
  * 2.具体使用:
  * 2.1 可变个数形参的格式:数据类型 ... 变量名
  * 2.2 当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,。。。
  * 2.3 可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
  * 2.4 可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。换句话说,二者不能共存。
  * 2.5 可变个数形参在方法的形参中,必须声明在末尾
  * 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

2.举例说明:

  

public void show(int i){ 
         
    } 
     
    public void show(String s){ 
        System.out.println("show(String)"); 
    } 
     
    public void show(String ... strs){ 
        System.out.println("show(String ... strs)"); 
         
        for(int i = 0;i < strs.length;i++){ 
            System.out.println(strs[i]); 
        } 
    } 
    //不能与上一个方法同时存在 
//    public void show(String[] strs){ 
//         
//    } 
调用时: 
        test.show("hello"); 
        test.show("hello","world"); 
        test.show(); 
         
        test.show(new String[]{"AA","BB","CC"});

java的值传递机制

  1.针对于方法内变量的赋值举例:

  

System.out.println("***********基本数据类型:****************"); 
        int m = 10; 
        int n = m; 
         
        System.out.println("m = " + m + ", n = " + n); 
         
        n = 20; 
         
        System.out.println("m = " + m + ", n = " + n); 
         
        System.out.println("***********引用数据类型:****************"); 
         
        Order o1 = new Order(); 
        o1.orderId = 1001; 
         
        Order o2 = o1;//赋值以后,o1和o2的地址值相同,都指向了堆空间中同一个对象实体。 
         
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId); 
         
        o2.orderId = 1002; 
         
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId); 
        

递归方法

  1.定义:
  递归方法:一个方法体内调用它自身。

  2.如何理解递归方法?

  > 方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。
  > 递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。

  3.举例:

  

// 例1:计算1-n之间所自然数的和 
    public int getSum(int n) {// 3 
 
        if (n == 1) { 
            return 1; 
        } else { 
            return n + getSum(n - 1); 
        } 
 
    } 
 
    // 例2:计算1-n之间所自然数的乘积:n! 
    public int getSum1(int n) { 
 
        if (n == 1) { 
            return 1; 
        } else { 
            return n * getSum1(n - 1); 
        } 
 
    } 
     
    //例3:已知一个数列:f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n), 
    //其中n是大于0的整数,求f(10)的值。 
    public int f(int n){ 
        if(n == 0){ 
            return 1; 
        }else if(n == 1){ 
            return 4; 
        }else{ 
//            return f(n + 2) - 2 * f(n + 1); 
            return 2*f(n - 1) + f(n - 2); 
        } 
    } 
 
    //例4:斐波那契数列 
     
    //例5:汉诺塔问题 
     
    //例6:快排

发布评论
IT序号网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

面向对象-上之类与对象知识解答
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。