[2017.10.3]变量&构造方法&方法重载&继承

一. 变量
1.关于变量的作用域:

①成员变量:

类的属性

②局部变量:

方法中定义的变量或者是方法的形式参数

对于java语言来说，作用域控制是通过块来控制的.

③块的概念: 

一对{}包裹,该代码片段就称为一块.

④对于某个块内定义的变量：

a.对于当前的块,不能再定义同名的变量,即使类型不同也不行.

b.对于当前的块,定义了某个变量,在块外不能够访问到块中定义的变量

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

2.练习:

①定义一个类，类中有2个成员变量，再分别定义两个方法，这两个方法的作用是给成员变量赋值.
public class Exercise1 {
int a;
int b;

Exercise1(int parmA,int parmB){
a = parmA;
b = parmB;
System.out.println("constructor");
}
    
Exercise1(){
    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){
    Exercise1 exer1 = new Exercise1();
    Exercise1 exer2 = new Exercise1(5,6);
    System.out.println(exer1.getAPlusB());
    System.out.println(exer2.getAPlusB());
    }
}

二. 构造方法(构造器)
1.类中特殊的方法，对于定义来讲，它的方法名必须和类名一模一样，并且不返回任何的值，主要不能添加void.
2.在new（创建一个对象的时候），一定会去调用它的构造方法.如果没有自己添加自己定义的构造器的话，编译器会帮我们添加一个默认的构造器;
 如果主动添加一个默认的构造器,那么在创建对象的时候,通过new类名(); 会调用我们自己添加的默认构造器;
 当我们主动添加了一个包含参数列表的构造器，并且没有主动添加默认的构造器，则再通过new 类名(); 就会遇到编译问题.

3.方法:

类名(){

  
  }

4.练习:

//输出性别
public class Person{

int age;
int height;
int weight;
boolean sex;

Person(int ageParm,int heightParm,int weightParm,boolean sexParm){
age = ageParm;
height= heightParm;
weight = weightParm;
sex = sexParm;
}

Person(int weightParm,boolean sexParm){
weight = weightParm;
sex = sexParm;
}


void getSex(){
if(sex){
System.out.println("男孩");
return;
}
System.out.println("女孩");
}


public static void main(String[] args){
Person lily = new Person(20,172,55,false);
lily.getSex();

}
}

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

2.当我们定义多个重载的方法的时候，在编译阶段的话，编译器可以根据我们方法形式参数数量以及类型来区别不同的方法，
执行阶段可以根据我们调用的时候传入的参数列表，仅仅拥有不同的返回值类型，是不被视为重载的。
  
3.练习:
   定义一个类，类中有个1维数组的成员变量(short).提供两个方法,第一个方法接受一个int数组,第二个方法接受一个long型的数组.
   两个方法均将各自形参传入的数组中元素的值进行求和.并且与本身我们类成员变量数组的和做一个差.最终返回这样的结果.
   public class Exercise {
short[] arrShort;
int sum;

void Exercise(){

}

Exercise(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){
Exercise test = new Exercise(3);

int sum1 = test.getArrPlusResult(new int[]{1,2,3});
long sum2= test.getArrPlusResult(new long[]{1,2,3});

test.Exercise();
System.out.println(sum1);
System.out.println(sum2);
}
}
   
   
四. 类的继承

 1.子类继承或者说派生自父类。子类可以享有父类的方法。在初始化一个子类对象的时候，调用其中的方法，如果该方法中在父类也有定义，

 并且参数列表不同，则调用到的是子类特有的方法。否则调用的是父类方法。

 

2.注意：

 如果仅仅是他们的返回值类型不同，则会出现编译错误.

 3.练习

 ①
 public class People{

String name ;
String nationality;

void eat(){
System.out.println("people eat");
}

public static void main(String[] args){

Student lily = new Student();
lily.eat();
lily.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");
}
}

 
 ②public class Animal{

void eat(){
System.out.println("Animal eat");
}

public static void main(String[] args){
    Animal dog = new Animal();
    dog.eat();
   
    Bird bird = new Bird();
    bird.fly();
    
   
    }
}
    
class Bird extends Animal{
void eat(){
System.out.println("bird eat");
}
void fly(){
System.out.println("bird fly");
}
}