一.构造函数
构造函数的作用: 初始化对应的对象。
构造函数的格式:
修饰符 函数名(形式参数){
函数体
}
构造函数要注意的事项:
1. 构造函数是没有返回值类型的。
2. 构造函数的函数名是必须与类名一致。
3. 构造函数不是由我们手动调用的,是我们在创建了对应的对象时,jvm会根据你创建的对象传递的参数调用
对应 的对象。
4. 如果一个类没有显示写上一个构造函数的时候,那么java编译器会为该类添加一个无参 的构造函数。
5. 如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参 的构造函数。
6. 构造函数是可以以函数重载的形式存在多个。
构造函数与普通 函数的区别:
1. 返回值类型的区别:
1. 构造函数是没有返回值类型 的,
2. 普通函数是有返回值类型的,即使函数没有返回值,返回值类型也要写上void。
2. 函数名的区别:
1. 构造函数的函数名必须要与类名一致,
2. 普通函数的函数名只要符合标识符的命名规则即可。
3. 调用方式的区别:
1. 构造函数是 在创建对象的时候由jvm调用的。
2. 普通函数是由我们使用对象调用的,一个对象可以对象多次普通 的函数,
4. 作用上的区别:
1. 构造函数 的作用用于初始化一个对象。
2. 普通函数是用于描述一类事物的公共行为的。
public class Demo1 {
public static void main(String[] args) {
/*
无参构造函数:
Baby b1=new Baby();
b1.name="vivi";
b1.id=20;
System.out.println(b1.id+","+b1.name);
b1.cry();
输出:
无参构造函数
20,vivi
vivi哇哇的哭。。。
*/
//带参构造函数:
Baby b1=new Baby(10,"vivi");
b1.name="vivi";
b1.id=20;
System.out.println(b1.id+","+b1.name);
b1.cry();
}
}
class Baby{
int id;
String name;
//带参构造函数
public Baby(int i,String n) {
id=i;
name=n;
System.out.println("带参构造函数!!");
}
//无参构造函数
public Baby() {
System.out.println("无参构造函数");
}
//普通函数-哭
public void cry() {
System.out.println(name+"哇哇的哭。。。");
二.构造代码块
构造代码块的作用:给对象进行统一的初始化。
构造函数的作用: 给对应的对象进行初始化。
构造代码块的格式:
{
构造代码块
}
*注意: 构造代码块的大括号必须位于成员 位置上。
*
代码块的类别:
1. 构造代码块。
2. 局部代码块. 大括号位于方法之内。 作用:缩短局部 变量 的生命周期,节省一点点内存。
3. 静态代码块 static
构造 代码块要注意的事项:
- java编译器编译一个java源文件的时候,会把成员变量的声明语句提前至一个类的最前端。
- 成员变量的初始化工作其实都在在构造函数中执行的。
- 一旦经过java编译器编译后,那么构造代码块的代码块就会被移动构造函数中执行,是在构造函数之前执行的,构造函数的中代码是最后执行 的。
- 成员变量的显示初始化与构造代码块 的代码是按照当前代码的顺序执行的。
class Baby{
int id; //身份证
String name; //名字
//构造代码块...
{
System.out.println("构造代码块的代码执行了......");
}
//带参构造函数
public Baby(int i , String n){
id = i;
name = n;
}
//无参构造方法
public Baby(){
}
//普通函数
public void cry(){
System.out.println(name+"哇哇哭...");
}
}
class Demo4 {
public static void main(String[] args){
Baby b1 = new Baby(110,"狗娃"); // 狗娃 狗剩 铁蛋
System.out.println("编号:"+ b1.id + " 名字:"+b1.name);
}
}
三.this关键字
this关键字代表了所属函数的调用者对象。
this关键字作用:
1. 如果存在同名成员变量与局部变量时,在方法内部默认是访问局部变量的数据,可以通过this关键字指定访问成员变量的数据。
2. 在一个构造函数中可以调用另外一个构造函数初始化对象。
this关键字调用其他的构造函数要注意的事项:
1. this关键字调用其他的构造函数时,this关键字必须要位于构造函数中 的第一个语句。
2. this关键字在构造函数中不能出现相互调用 的情况,因为是一个死循环。
class Person{
int id; //编号
String name; //姓名
int age; //年龄
//构造函数
public Person(int id,String name ,int age){
this.id = id;
this.name = name;
this.age = age;
}
//比较年龄的方法
public void compareAge(Person p2){
if(this.age>p2.age){
System.out.println(this.name+"大!");
}else if(this.age<p2.age){
System.out.println(p2.name+"大!");
}else{
System.out.println("同龄");
}
}
}
class Demo8{
public static void main(String[] args)
{
Person p1 = new Person(110,"狗娃",17);
Person p2 = new Person(119,"铁蛋",9);
p1.compareAge(12);
}
}
四.static(静态、修饰符)
static修饰成员变量时:该成员变量的数据就是一个共享的数据.
静态成员变量的访问方式:
- 方式一: 使用对象进行访问。 对象.属性名
- 方式二:可以使用类名进行访问。 类名.属性名
注意:
1. 非静态成员变量不能类名直接访问,只能使用对象进行访问。
2. 千万不要为了方便访问成员变量而使用static修饰,一定要是该数据是共享数据 时才使用static修饰。
static修饰方法(静态的成员方法):
访问方式:
- 方式一:可以使用对象进行访问。 对象.静态的函数名();
- 方式二:可以使用类名进行访问。 类名.静态函数名字。推荐使用是类名直接访问静态的成员。
静态的成员变量与非静态的成员变量的区别:
- 作用上的区别:
- 静态的成员变量的作用共享一个 数据给所有的对象使用。
- 非 静态的成员变量的作用是描述一类事物的公共属性。
- 数量与存储位置上的区别:
- 静态成员变量是存储方法 区内存中,而且只会存在一份数据。
- 非静态的成员变量是存储在堆内存中,有n个对象就有n份数据。
- 生命周期的区别:
- 静态的成员变量数据是随着类的加载而存在,随着类文件的消失而消失。
2.非静态的成员数据是随着对象的创建而存在,随着 对象被垃圾回收器回收而消失。
静态函数要注意的事项:
静态函数是可以调用类名或者对象进行调用的,而非静态函数只能使用对象进行调用。
静态的函数可以直接访问静态的成员,但是不能直接访问非静态的成员。
原因:静态函数是可以使用类名直接调用的,这时候可能还没有存在对象, 而非静态的 成员数据是随着对象 的存在而存在的。非静态的函数是可以直接访问静态与非静态的成员。
原因:非静态函数只能由对象调用,当对象存在的时候,静态数据老早就已经存在了,而非静态 数据也随着对象的创建而存在了。静态函数不能出现this或者super关键字。
原因:因为静态的函数是可以使用类名调用的,一旦使用类名调用这时候不存在对象,而this 关键字是代表了一个函数的调用者对象,这时候产生了冲突。
静态的数据的生命周期:静态的成员变量数据是优先于对象存在的。
静态函数不能访问非静态的成员?
静态函数只要存在有对象,那么也可以访问非 静态的数据。只是不能直接访问而已。
public class Demo6 {
public static void main(String[] args) {
Teacher s1 = new Teacher("张三");
Teacher s2 = new Teacher("陈七");
s1.country = "小日本";
System.out.println("姓名:"+s1.name+" 国籍:"+ s1.country);
System.out.println("姓名:"+s2.name+" 国籍:"+ s2.country);
}
}
class Teacher{
String name;
//使用了static修饰country,那么这时候country就是一个共享的数据。
static String country = "中国"; //国籍
//构造函数
public Teacher(String name){
this.name = name;
}
}
姓名:张三 国籍:小日本
姓名:陈七 国籍:小日本
public class Demo6 {
public static void main(String[] args) {
Teacher s1 = new Teacher("张三");
Teacher s2 = new Teacher("陈七");
s1.country = "小日本";
System.out.println("姓名:"+s1.name+" 国籍:"+ s1.country);
System.out.println("姓名:"+s2.name+" 国籍:"+ s2.country);
}
}
class Teacher{
String name;
//使用了static修饰country,那么这时候country就是一个共享的数据。
String country = "中国"; //国籍
//构造函数
public Teacher(String name){
this.name = name;
}
}
姓名:张三 国籍:小日本
姓名:陈七 国籍:中国
static什么时候修饰一个函数?
如果一个函数没有直接访问到非静态的成员时,那么就可以使用static修饰了。 一般用于工具类型的方法
例如:以下代码
/*
需求:编写一个数组的工具类。
Arrays.toString() [1,2,3,4];
sort()
*/
//数组工具类
class ArrayTool{
public static String toString(int[] arr){
String result = "";
for(int i = 0; i < arr.length ; i++){
if (i==0){
result+="["+arr[i]+",";
}else if(i==(arr.length-1)){
result+= arr[i]+"]";
}else{
result+=arr[i]+",";
}
}
return result;
}
public static String toString(int [] arr){
String result="";
for(int i=0;i<arr.length;i++){
if(i==0){
result="["+arr[i]+","+result;
}else if(i==(arr.length-1)){
result=arr[i]+"]";
}else{
result=arr[i]+","+result;
}
}
}
public static void sort(int[] arr){
for(int i = 0; i < arr.length-1 ; i++){
for(int j = i+1 ; j<arr.length ; j++){
if(arr[i]>arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}
class Demo3
{
public static void main(String[] args)
{
int[] arr = {12,1,456,165};
//ArrayTool tool = new ArrayTool();
ArrayTool.sort(arr);
String info = ArrayTool.toString(arr);
System.out.println("数组的元素:"+ info);
}
}