回忆构造器及静态变量

今天学习主要学习的的是静态变量的概念及其使用。下面是我关于静态变量的一些看法。

静态变量通俗的说是属于类的属性。如果一个类要进行实例化，通过实例可以调用静态变量，类名也可以直接调用静态变量。如果实例化两个类的话。被static修饰的变量相当于是两个公共的属性。其中一个实例修改静态变量的话。那么其他的实例再进行调用的话会调用被修改的那个实例。例如以下代码就是可以清晰的显示出静态变量的的相关使用。变量a和变量b是静态变量。

public class Test1 {
public static void main(String[] args) {
System.out.println(A.a);
A a1 = new A();
A a2 = new A();
System.out.println("修改之前 "+a1.a);
System.out.println("修改之前 "+a2.a);
a1.a = 12;
System.out.println("修改之后 "+a1.a);
System.out.println("修改之后 "+a2.a);
System.out.println("修改之前 "+a1.c);
System.out.println("修改之前 "+a2.c);
a1.show(34);
System.out.println("修改之后 "+a1.c);
System.out.println("修改之后 "+a2.c);
B b1 = new B();
b1.get();
B.get1();
b1.get1();

System.out.println("通过类名直接调用"+A.a);


}
}
class A {
static int a = 5;
static int b = 7;
int c = 45;
public void show (int c) {
this.c = c;
}
}
class B {
int a = 5;
static int b = 45;
public void get () {
System.out.println(a);
}
static void get1 () {
System.out.println(b);
}
}

同理可得，静态方法的使用和概念是跟静态变量相同的,可看成一个是静态的属性（静态变量），一个是动态的属性（静态方法）。

构造器

　当然对于java，类的概念是重中之重，对于类的构造和对象的实现就需要用到构造器。

构造器具有初始化的作用。 
　　例如public class Person(){ 
　　　　private string name; 
　　　　private int number; 
　　　　public Person(string n,int no){ 
　　　　name=n; 
　　　　number=no; 
　　　　} 
　　　　public teach(){}　 
　　 } 
　　下面我们要对这个类的对象实例化：Person p = new Person();
　　以上就是构造器的语法了，这里用到了关键字来调用构造器。 
　　new 
　　
　　讲到这里还没有什么可以困扰我们的地方，那么下面我们将借助有关继续的一些例子来继续阐述构造器问题： 
　　假设publicclass People(){ 
　　　　 private string name; 
　　　　 private int number ; 
　　　　 private int age; 
　　　　 public do(){} 
　　　　}　 
　　
　　有人也许会问为什么这个People类里面为什么没有定义构造器？其实，java中的JVM已经我们定义了一个无参数的默认构造器，即People(){} 
　　到这里为止，没有任何问题,然而，一旦让People继承OldPeople并实例化，编译器就会报错: 
　　　　　public class People extends OldPeople(){ 
　　　　　　　private string name; 
　　　　　　　private int number ; 
　　　　　　　private int age; 
　　　　　
　　　　　　　public do(){} 
　　　　public static void mian(string[] args){ 
　　　　　　　OldPeople o=new OldPeople(); 
　　　　} 
　　很抱歉你得到的是一条出错的信息，有人问了，你说OldPeople的构造器是默认的我才这样写，没错，OldOldPeople确实存在这样一个无参的构造器，这样写法换做OldPeople不做People的子类的情况下一定是正确的。 
　　
　　　 构造器的相关规则：
　　1.假如一个类没有设置字定义构造器，那么编译器会默认一个无参构造器。 
　　2.在子类调用构造器时，优先调用父类的构造器。 
　　3.假如自定义了构造器，那么默认构造器将不存在。 
　　
　　　在上例中，OldPerson调用默认构造器前，编译器自动调用父类Professer的默认构造器，然而，Person有了自定义构造器，所以默认构造器不存在了，编译器报错………… 
　　　　那么我们该怎么做呢？像下面这样就OK了。 
　　
　　　　public class People extends OldPeople(){ 
　　　　　　　 private string name; 
　　　　　　　 private int number; 
　　　　　　　 private int age; 
　　　　　　　 OldPeople(string n,int no,int age){ 
　　　　　　　 super(n,no); 
　　　　　　　 this.age=age; 
　　　　　　　 } 
　　　　　　　 public do(){} 
　　　　　} 
　　 　
　　　　 这就是在子类中显式的调用父类构造器，注重，super必须是{}中的第一个执行语句。其实我们还有另外一种方法，在People类里面补充一个消失掉的默认构造器，如下： 
　　　 
　　　public　class People(){ 
　　　　　 private string name; 
　　　　　 private int number; 
　　　　　 public People(string n,int no){ 
　　　　　 name=n; 
　　　　　 number=no; 
　　　　 } 
　　　　　People(){} 
　　　　　 public teach(){}　 
　　　} 
　　构造器尽量使用的功能是传参数的功能，不要包含太多的操作语句即可。

如下例子：通过构造器将变量a,和变量b的值赋值。之后通过实例化对象进行调用方法。

import java.util.Scanner;
public class Count {
public static void main(String[] args) {
System.out.println("请输入第一个数字");
Scanner in = new Scanner(System.in);
int a = in.nextInt();
System.out.println("请输入第二个数字");
int b = in.nextInt();


Count1 co = new Count1 (a,b);
co.add();
co.sub();
co.mul();
co.div();
}
}
class Count1 {
int a ;
int b ;
public Count1 (int a,int b) {
this.a = a;
this.b = b;
}
public void add() {
int d = a + b;
System.out.println(d);
}
public void sub() {
int e = a - b;
System.out.println(e);
}
public void mul() {
int f = a/b;
System.out.println(f);
}
public void div() {
int g = a / b;
System.out.println(g);
}
}

今天就写到了。