黑马程序员-----Java基础-----构造函数

      ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

构造函数:

  函数名与类名相同
  构造函数 对象一建立调用与之对应的构造函数
 作用：可以用于给对象进行初始化。 
  当一个类中没有定义构造函数，系统会默认给该类加入一个空参数的构造函数。
  class Person{
  private String name；
 private int age；
  
 Person()
 {System。out。println("A:name="+name+"age="+age);  }
 
  Person(){
  name = n;
  System。out。println("A:name="+name+"age="+age);  }
  
  Person(){
 name = n;
 age = a;
 System。out。println("A:name="+name+"age="+age);  }
  
  class PersonDemo{
  public static void main(String[] args){
  Person p = new Person();
  new Person();
  }
  }
  }
  }
  
  
  构造函数和一般函数在写法上不同
  在运行上也不同
  构造函数是在对象一建立就运行，给对象初始化。
  而一般函数是对象调用才执行，给对象添加具备的功能。
  一个对象的建立，构造函数只运行一次。
  而一般函数可以被该对象调用多次。
  
  什么时候定义构造函数
  当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数里。
  
  
  构造代码块
  作用;给对象进行初始化，
  对象一建立就运行，而且优先于构造函数执行，
  与构造函数区别：
  构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
 
 {-----------------}共性的内容
  
  this：看上去，是用于区分局部变量和成员变量同名情况。
  this：代表他所在函数所属对象的引用。（哪个对象在调用this所在的函数，this就代表那个对象）
   this应用：当定义类中的功能是，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象
   但凡本类功能内部使用了本类对象，都用this表示。
   boolean b = p1.compare(p2);
   public boolean compare(Person p)
{
return this.age==p.age;
}
  p1调用compare，this就是p1.
   
    Person(String name)
{
this.name = name;
}
Person(String name,int age)
{
//this.name = name;
   this(name)与以上语句一样功能
   
this.age = age;
构造函数间调用 只能用this 只能放在构造函数的第一行。


需求：给人定义一个比较，是否是同龄人。


public class gouzaohanshu {



public static void main(String[] args) 
{
Person p1 = new Person(25);
Person p2 = new Person(25);
boolean b = p1.compare(p2);
System.out.println(b);


}


}
class Person
{
private String name;
private int age;
Person(int age)
{
this.age = age;
}
Person(String name)
{
this.name = name;
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}

public boolean compare(Person p)
{
return this.age==p.age;
}

}






 静态：static。
 用法：是一个修饰符，用于修饰成员变量和成员函数。
 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用：类名。静态成员。
 
 System.out.println(p.country);
 =System.out.println(Person.country);
 
 static特点
 1，随着类的加载而加载
 2，优先于类的对象存在
 3，被所有对象所共享
 4，可以直接被类名调用
 
 注意事项：
 1，静态方法只能访问静态成员。
 2，静态方法中不可以定义this，super，因为静态优先于对象存在，所以静态方法中不可以。
 
 静态利弊：
 利：对对象共享，节省空间。可以直接被类名调用。
 弊：生命周期过长，访问出现局限性。


class Person
{
String name;
String country = "CN";
public void show()
{
System.out.println(name+"::"+country);
}
}
class StaticDemo
{
public static void main(String args [])
{
Person p = new Person();
p.name = "zhangsan";
p.show();
}
}


 主函数：是一个特殊的函数，作为程序入口，可以被jvm调用。
 主函数定义：
 public 代表着该函数访问权限是最大的。
 static 代表主函数随着类的加载就已经存在了。
 void   主函数没有具体的返回值。
 main   不是关键字，是一个特殊单词，被jvm识别。
 参数（）          函数的参数，参数是一个数组，该数组中的元素是字符串，字符串类型的数组。
 主函数是固定格式的：jvm识别。


静态的应用--工具类
每一个应用程序中都有共性的功能。
可以讲这些功能进行抽取，独立封装，以便复用。


虽然可以通过建立arraytool的对象使用工具方法，对数组进行操作，
发现问题：
1.对象是用于封装数据的，可是arraytool对象并未封装特有数据，
2.操作数组的每一方法都没有用到arraytool对象中的特有数据。


这是考虑，让程序更严谨，是不需要对象的。
可以将arraytool中的方法都定义成static的。直接通过类名调用建立对象。


将方法都静态后，方便使用，但是该类型还是可以被其他程序建立对象的。
为了更为严谨，强制该类不能建立对象，
可以通过将构造函数私有化完成。


class ArrayTool
{
private RArrayTool(){}


。。。
}


----------------------


class ArrayTool
{
public int getMax(int [] arr)
{
int max = 0;
for (int x = 1 ; x < arr.length ;x++)
{
if(arr[x] >arr[max])
{
max=x;
}

}
return arr[max];
}
public int getMin(int [] arr)
{
int min = 0;
for (int x = 1 ; x < arr.length ;x++)
{
if(arr[x] < arr[min])
{
min=x;
}

}
return arr[min];
}
public void selecSort(int [] arr)
{
for(int x=0 ;x < arr.length ;x++)
{
for(int y=x+1 ; y <arr.length ;y++ )
{
if(arr[x] > arr[y])
{
swap(arr,x,y);
}
}
}
}
public void bubbleSort(int [] arr)
{
for(int x=0 ;x < arr.length-1 ;x++)
{
for(int y=0 ; y <arr.length-x-1 ;y++ )
{
if(arr[y] > arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}
public void swap(int [] arr,int a , int b)
{
int temp = arr(a);
arr[a] = arr[b];
arr[b] = temp;
}
}
 
 
 
调用
public class ArrayToolDemo {
public static void main(String args [])
{
int[] arr = {2,4,5,7,8,9,0,4,5,7,1};
ArrayTool t = new ArrayTool();
t.getMax(arr);
System.out.println(t.getMax(arr));
}
}
 
 工具类中定义成静态，调用时不需要创建对象，直接用类名。函数名调用
int[] arr = {2,4,5,7,8,9,0,4,5,7,1};
ArrayTool t = new ArrayTool();
t.getMax(arr);
System.out.println(t.getMax(arr));

==ArrayTool。getMax(arr);

 System.out.println(t.getMax(arr));

                              -----------android培训、java培训、java学习型技术博客、期待与您交流！------------