java构造方法从基础到入门.docx
《java构造方法从基础到入门.docx》由会员分享，可在线阅读，更多相关《java构造方法从基础到入门.docx（29页珍藏版）》请在冰豆网上搜索。
java构造方法从基础到入门
/*
构造函数：
构造函数的作用：
初始化对应的对象。
构造函数的格式：
修饰符函数名（形式参数）{
函数体
}
构造函数要注意的事项：
1.构造函数是没有返回值类型的。
2.构造函数的函数名是必须与类名一致。
3.构造函数不是由我们手动调用的，是我们在创建了对应的对象时，jvm会根据你创建的对象传递的参数调用
对应的对象。
4.如果一个类没有显示写上一个构造函数的时候，那么java编译器会为该类添加一个无参的构造函数。
5.如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参的构造函数。
6.构造函数是可以以函数重载的形式存在多个。
构造代码块：
构造代码块的作用：
给对象进行统一的初始化。
构造代码块的格式：
{
代码；
}
构造代码块是在创建了代码块所属类的对象时调用一次。
this关键字：
this关键字代表了所属函数的调用者对象。
this关键字的作用：
1.一个类中存在同名的成员变量与局部变量时，在方法的内部默认是访问局部变量的，可以通过this关键字指定访问成员变量的数据。
2.this关键字还可以在构造函数中调用另外一个构造函数初始化对象，
this关键字调用构造函数要注意的事项：
1.this关键字调用其他的构造函数时，必须要是在第一个语句。
2.this关键字调用构造函数时不能出现相互调用，因为是一个死循环。
3.如果在方法的内部访问一个变量时，该变量只存在于成员变量中，局部没有没有，这时候java编译器会为该变量的前面添加this关键字。
static（静态、修饰符）
static修饰成员变量时：
static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.
静态成员变量的访问方式：
方式一：
使用对象进行访问。
对象.属性名
方式二：
可以使用类名进行访问。
类名.属性名
注意：
1.非静态成员变量不能类名直接访问，只能使用对象进行访问。
2.千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据时才使用static修饰。
*/
classDemo1
{
publicstaticvoidmain（String[]args）
{
System.out.println（"HelloWorld!
"）;
}
}
/*
static（静态、修饰符）
static修饰成员变量时：
static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.
静态成员变量的访问方式：
方式一：
使用对象进行访问。
对象.属性名
方式二：
可以使用类名进行访问。
类名.属性名
注意：
1.非静态成员变量不能类名直接访问，只能使用对象进行访问。
2.千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据时才使用static修饰。
static修饰方法（静态的成员方法）:
访问方式：
方式一：
可以使用对象进行访问。
对象.静态的函数名（）;
方式二：
可以使用类名进行访问。
类名.静态函数名字。
推荐使用是类名直接访问静态的成员。
静态的成员变量与非静态的成员变量的区别：
1.作用上的区别：
1.静态的成员变量的作用共享一个数据给所有的对象使用。
2.非静态的成员变量的作用是描述一类事物的公共属性。
2.数量与存储位置上的区别：
1.静态成员变量是存储方法区内存中，而且只会存在一份数据。
2.非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
3.生命周期的区别：
1.静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
2.非静态的成员数据是随着对象的创建而存在，随着对象被垃圾回收器回收而消失。
静态函数要注意的事项：
1.静态函数是可以调用类名或者对象进行调用的，而非静态函数只能使用对象进行调用。
2.静态的函数可以直接访问静态的成员，但是不能直接访问非静态的成员。
原因：
静态函数是可以使用类名直接调用的，这时候可能还没有存在对象，
而非静态的成员数据是随着对象的存在而存在的。
3.非静态的函数是可以直接访问静态与非静态的成员。
原因：
非静态函数只能由对象调用，当对象存在的时候，静态数据老早就已经存在了，而非静态
数据也随着对象的创建而存在了。
4.静态函数不能出现this或者super关键字。
原因：
因为静态的函数是可以使用类名调用的，一旦使用类名调用这时候不存在对象，而this
关键字是代表了一个函数的调用者对象，这时候产生了冲突。
静态的数据的生命周期：
静态的成员变量数据是优先于对象存在的。
static什么时候修饰一个函数？
如果一个函数没有直接访问到非静态的成员时，那么就可以使用static修饰了。
一般用于工具类型的方法
静态函数不能访问非静态的成员？
静态函数只要存在有对象，那么也可以访问非静态的数据。
只是不能直接访问而已。
*/
classStudent{
Stringname;//名字
staticStringcountry="中国";//国籍
//静态代码块：
静态代码块是在Student.class文件加载到内存的时候就马上执行的。
static{
System.out.println（"静态代码块执行了..."）;
}
//构造函数
publicStudent（Stringname）{
this.name=name;
}
//非静态的成员函数
publicvoidstudy（）{
System.out.println（"好好学习"+this）;
}
//静态函数
publicstaticvoidsleep（）{//静态方法与非静态方法的字节码文件是同时存在内存中的。
只是静态的成员变量数据是优先于对象存在而已。
Students=newStudent（"铁蛋"）;
System.out.println（s.name+"呼呼大睡..."）;
}
}
classDemo2
{
publicstaticvoidmain（String[]args）
{
Student.sleep（）;
//Students=newStudent（"狗娃"）;
}
}
/*
需求：
编写一个数组的工具类。
Arrays.toString（）[1,2,3,4];
sort（）
*/
//数组工具类
classArrayTool{
publicstaticStringtoString（int[]arr）{
Stringresult="";
for（inti=0;iif（i==0）{
result+="["+arr[i]+",";
}elseif（i==（arr.length-1））{
result+=arr[i]+"]";
}else{
result+=arr[i]+",";
}
}
returnresult;
}
publicstaticStringtoString（int[]arr）{
Stringresult="";
for（inti=0;iif（i==0）{
result="["+arr[i]+","+result;
}elseif（i==（arr.length-1））{
result=arr[i]+"]";
}else{
result=arr[i]+","+result;
}
}
}
publicstaticvoidsort（int[]arr）{
for（inti=0;ifor（intj=i+1;jif（arr[i]>arr[j]）{
inttemp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
}
classDemo3
{
publicstaticvoidmain（String[]args）
{
int[]arr={12,1,456,165};
//ArrayTooltool=newArrayTool（）;
ArrayTool.sort（arr）;
Stringinfo=ArrayTool.toString（arr）;
System.out.println（"数组的元素：
"+info）;
}
}
/*
main函数的详解：
public：
公共的。
权限是最大，在任何情况下都可以访问。
private
原因：
为了保证让jvm在任何情况下都可以访问到main方法。
static:
静态。
静态可以让jvm调用main函数的时候更加的方便。
不需要通过对象调用。
void:
没有返回值。
因为返回的数据是给jvm，而jvm使用这个数据是没有意义的。
所以就不要了。
main:
函数名。
注意：
main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。
arguments：
担心某些程序在启动需要参数。
*/
classDemo4{
publicstaticvoidmain（String[]args）
{
System.out.println（"数组的长度：
"+args.length）;
for（inti=0;iSystem.out.print（args[i]+","）;
}
Scannerscanner=newScanner（System.in）;
}
}
/*
单例设计模式：
保证一个类在内存中只有一个对象。
模式：
模式就是解决一类问题的固定步骤。
模式的概念最早起源于建筑行业....
建房子的步骤都是一样子：
打地基----->浇柱子------->盖楼面--------->砌墙--------->封顶---->装修-----入住
软件行业中23种设计模式：
单例设计模式
模板设计模式
装饰者设计模式
观察者设计模式
工厂设计模式
单例设计模式的步骤：
饿汉单例设计模式
1.私有化构造函数。
2.声明本类的引用类型变量，并且使用该变量指向本类对象。
3.提供一个公共静态的方法获取本类的对象。
懒汉单例设计模式：
1.私有化构造函数。
2.声明本类的引用类型变量，但是不要创建对象，
3.提供公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象
，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，
然后再返回。
推荐使用：
饿汉单例设计模式。
因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。
*/
//饿汉单例设计模式---->保证Single在在内存中只有一个对象。
classSingle{
//声明本类的引用类型变量，并且使用该变量指向本类对象
privatestaticSingles=newSingle（）;
//私有化构造函数
privateSingle（）{}
//提供一个公共静态的方法获取本类的对象
publicstaticSinglegetInstance（）{
returns;
}
}
classTest{
publicstaticTestt=newTest（）;
privateTest{}
publicstaticTestgetInstance（）{
returnt;
}
}
classTest{
publicstaticTestt;
privateTest{}
publicstaticTestgetInstance（）{
if（t==null）{
t=newTest（）;
}
returnt;
}
}
//懒汉单例设计模式---->保证Single在在内存中只有一个对象。
classSingle2{
//声明本类的引用类型变量，不创建本类的对象
privatestaticSingle2s;
//私有化了构造函数
privateSingle2（）{}
//
publicstaticSingle2getInstance（）{
if（s==null）{
s=newSingle2（）;
}
returns;
}
}
classDemo5
{
publicstaticvoidmain（String[]args）
{
Single2s1=Single2.getInstance（）;
Single2s2=Single2.getInstance（）;
System.out.println（"是同一个对象吗？
"+（s1==s2））;
}
}
/*
在现实生活中事物与事物之间是存在关系.
球员---->球队整体与部分关系hasa关系
学生----->人继承的关系isa关系
*/
//球员类
classPlayer{
intnum;//编码
Stringname;
publicPlayer（intnum,Stringname）{
this.num=num;
this.name=name;
}
publicvoidrun（）{
System.out.println（name+"开跑..."）;
}
}
//球队类
classTeam{
Stringname;//球队的名字
Playerp1;//球员1
Playerp2;//球员2
Playerp3;//球员3
publicTeam（Stringname,Playerp1,Playerp2,Playerp3）{
this.name=name;
this.p1=p1;
this.p2=p2;
this.p3=p3;
}
//开始比赛
publicvoidstartGame（）{
System.out.println（name+"开赛啦！
！
"）;
}
}
classDemo6
{
publicstaticvoidmain（String[]args）
{
Playerp1=newPlayer（12,"梅西"）;
Playerp2=newPlayer（7,"C罗"）;
Playerp3=newPlayer（11,"内马尔"）;
//球队
Teamt=newTeam（"恒大",p1,p2,p3）;
t.startGame（）;
System.out.println（"名字：
"+t.p2.name）;
}
}
/*
目前存在的问题：
1.无法描述清楚这两个类之间的继承关系。
2.存在着重复代码。
面向对象的三大特征：
1.封装
2.继承
3.多态.
继承：
继承是通过关键字extends体现的。
继承的格式：
class类名1extends类名2{
}
继承要注意的事项：
1.千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
2.父类私有的成员不能被继承。
3.父类的构造函数不能被继承。
4.创建子类对象时默认会先调用父类无参的构造函数。
*/
//人类
classPerson{
Stringname;
privateintage;
publicPerson（Stringname）{
this.name=name;
}
publicPerson（）{
System.out.println（"Person类的构造方法被调用了...."）;
}
publicvoideat（）{
System.out.println（name+"在吃饭..."）;
}
}
//学生类
classStudentextendsPerson{//Student就称作为Person类的子类，Person类就称作为Student的父类（超类、基类）
intnum;//学号
publicStudent（）{
System.out.println（"Student类的构造方法被调用了...."）;
}
publicvoidstudy（）{
System.out.println（name+"goodgoodstudy,daydayup"）;
}
}
classDemo7
{
publicstaticvoidmain（String[]args）
{
Students=newStudent（）;
/*
s.name="狗娃";
System.out.println（"名字：
"+s.name）;
s.eat（）;
*/
}
}
/*
疑问：
为什么要调用父类的构造方法啊？
这样子做的意义在那？
调用父类的构造方法是可以初始化从父类继承下去的属性的。
*/
classFu{
intx=10;
Stringname;
publicFu（Stringname）{
this.name=name;
System.out.println（"Fu类d带参的构造方法..."）;
}
publicFu（）{
System.out.println（"Fu类无参的构造方法..."）;
}
}
classZiextendsFu{
intx=20;
publicZi（Stringname）{
super（name）;//指定调用父类一个参数的构造函数。
}
publicvoidprint（）{
System.out.println（"x1="+x）;
}
}
classDemo8
{
publicstaticvoidmain（String[]args）
{
Ziz=newZi（"大头儿子"）;
System.out.println（"name="+z.name）;
}
}
/*
super关键字：
super关键字代表了父类空间的引用。
super关键字的作用：
1.子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
2.创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。
super关键字调用父类构造方法要注意的事项：
1.如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super（）语句。
2.super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
3.super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。
因为两个语句都需要第一个语句。
super关键字与this关键字的区别：
1.代表的事物不一致。
1.super关键字代表的是父类空间的引用。
2.this关键字代表的是所属函数的调用者对象。
2.使用前提不一致。
1.super关键字必须要有继承关系才能使用。
2.this关键字不需要存在继承关系也可使用。
3.调用构造函数的区别：
1.super关键字是调用父类的构造函数。
2.this关键字是调用本类的构造函数。
*/
classFu{
intx=10;
Stringname;
publicFu（）{
System.out.println（"Fu类无参的构造方法.."）;
}
publicFu（Stringname）{
this.name=name;
System.out.println（"Fu类带参的构造方法.."）;
}
publicvoideat（）{
System.out.println（"小头爸爸吃番薯.."）;
}
}
classZiextendsFu{
intx=20;
intnum;
publicZi（Stringname,intnum）{
super（name）;//指定调用了父类带参的构造方法...
this（）;//调用本类无参构造方法..
//super（）;//指定调用了父类无参构造方法。
。
。
System.out.println（"Zi类带参的构造方法.."）;
}
publicZi（）{
System.out.println（"Zi类无参的构造方法.."）;
}
publicvoidprint（）{
System.out.println（"x="+super.x）;
}
publicvoideat（）{
System.out.println（"大头儿子吃龙虾.."）;
}
}
classDemo9{
publicstaticvoidmain（String[]args）
{
Ziz=newZi（"狗娃"）;
}
}
/*
目前的问题：
父类的功能无法满足子类的需求。
方法重写的前提：
必须要存在继承的关系。
方法的重写:
子父类出了同名的函数，这个我们就称作为方法的重写。
什么是时候
升级会员 