您的位置: 首页  >  文章  >  java第五天/10.3

java第五天/10.3

分类: 文章 • 2024-02-05 10:56:58

一. 关于变量的作用域:

（1）、成员变量:
类的属性

（2）、局部变量:
方法中定义的变量或者是方法的形式参数。

对于java语言来说，作用域控制是通过块来控制的.
块的概念: 一对{} 包裹，该代码片段就称为 一块.

对于某个块内定义的变量：
a.对于当前的块，不能再定义同名的变量,即使类型不同也不行。
b.对于当前的块，定义了某个变量，在块外不能够访问到块中定义的变量

如果存在块的嵌套:
那么外层块定义的变量，在内层块中是可以访问到的.

课堂练习:

定义一个类，类中有2个成员变量，再分别定义俩个方法，这俩个方法的作用是给成员变量赋值.
public class ClassDemo{
int a;
int b;
ClassDemo(int parmA,int parmB){
a = parmA;
b = parmB;
System.out.println(“constructor”);
}
ClassDemo(){
System.out.println(“default constructor”);
}
void setA(int parmA){
a = parmA;
}
void setB(int parmB){
b = parmB;
}
int getAPlusB(){
return a+b;
}
public static void main(String[] args){
ClassDemo demo1 = new ClassDemo();
ClassDemo demo2 = new ClassDemo(10,20);
System.out.println(demo1.getAPlusB());
System.out.println(demo2.getAPlusB());
//System.out.println(demo1.getAPlusB());
}
}

java第五天/10.3
二. 构造方法(构造器)

1.类中特殊的方法，对于定义来讲，它的方法名必须和类名一模一样，并且不返回任何的值，主要不能添加void.
2.在new（创建一个对象的时候），一定会去调用它的构造方法。 但是如果我们没有自己添加自己定义的构造器的话，编译器会帮我们
偷偷的添加一个默认的构造器:

类名(){

}

如果我们主动添加一个默认的构造器，那么在创建对象的时候，通过new 类名(); 会调用我们自己添加的默认构造器.

3.当我们主动添加了一个包含参数列表的构造器，并且没有主动添加默认的构造器，则再通过new 类名(); 就会遇到编译问题.

三. 方法重载 overload

  1. 对于同名的方法，具有不相同的参数列表，我们在访问的时候，通过调用方法传入不同的参数列表，就可以找到我们特定的方法。

  2. 当我们定义多个重载的方法的时候，在编译阶段的话，编译器可以根据我们方法形式参数数量以及类型来区别不同的方法，执行阶段可以
    根据我们调用的时候传入的参数列表， 仅仅拥有不同的返回值类型，是不被视为重载的。

    练习:

    定义一个类，类中有个1维数组的成员变量(short)。 提供俩个方法，第一个方法接受一个int数组，第二个方法接受一个long型的数组。
    俩个方法均将各自 形参传入的数组中元素的值进行求和。 并且与本身我们类成员变量数组的和做一个差。 最终返回这样的结果。
    public class ClassTest2{
    short[] arrShort;
    int sum;
    void ClassTest2(){
    System.out.println(“ClassTest2 execute !”);
    }
    ClassTest2(int a){
    arrShort = new short[]{2,3,4};
    for(int i=0;i < arrShort.length;i++){
    sum+=arrShort[i];
    }
    }
    int getArrPlusResult(int[] arr){
    int sumAll = 0;
    for(int i=0;i < arr.length;i++){
    sumAll+=arr[i];
    }
    return sumAll - sum;
    }
    long getArrPlusResult(long[] arr){
    long sumAll = 0;
    for(int i=0;i< arr.length;i++){
    sumAll+=arr[i];
    }
    return sumAll - sum;
    }
    public static void main(String[] args){
    ClassTest2 test = new ClassTest2(3);
    int sum1 = test.getArrPlusResult(new int[]{1,2,3});
    long sum2= test.getArrPlusResult(new long[]{1,2,3});
    test.ClassTest2();
    System.out.println(“getArrPlusResult(int[] arr): result”+sum1);
    System.out.println(“getArrPlusResult(int[] arr): result”+sum2);
    }
    }
    java第五天/10.3
    四. 类的继承

    子类继承或者说派生自父类。子类可以享有父类的方法。在初始化一个子类对象的时候，调用其中的方法，如果该方法中在父类也有定义，
    并且参数列表不同，则调用到的是子类特有的方法。否则调用的是父类方法。
    注意：如果仅仅是他们的返回值类型不同，则会出现编译错误。
    public class People{
    String name ;
    String nationality;
    void eat(){
    System.out.println(“people eat”);
    }
    public static void main(String[] args){
    /*
    People green = new People();
    green.eat();
    Teacher wang = new Teacher();
    wang.eat();
    wang.teach();
    */
    Student king = new Student();
    king.eat();
    king.study();
    }
    }
    class Student extends People{
    String name;
    String nationality;
    void study(){
    System.out.println(“student study”);
    }
    int eat(){
    System.out.println(“Student eat:”+ a);
    return 0;
    }
    }
    class Teacher extends People{
    String name;
    String nationality;
    void teach(){
    System.out.println(“teacher teach”);
    }
    void eat(){
    System.out.println(“teacher eat”);
    }
    }
    java第五天/10.3

相关推荐