第一讲 构造函数
构造函数也叫构造方法,是方法名与类名相同,不用定义返回值类型,并且为对象进行初始化的特殊函数。对象一建立,就会调用与之对应的类的构造函数。
当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。
默认构造构造函数的权限是随着的类的变化而变化的。例如:如果类被public修饰,那么默认的构造函数也带public修饰符。
但是当在类中自定义了构造函数后,默认的构造函数就没有了。
构造函数和一般函数的区别:
1、构造函数是在对象一建立时就运行,为对象初始化;而一般方法则是需要对象调用时才能执行,主要是为对象添加所具备的功能。
2、一个对象建立后,构造函数只运行一次;而一般方法可以被该对象调用多次。
什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么就可以将这些内容定义在构造函数中。
构造代码块
作用:给对象进行初始化。
特点:对象一建立就运行,而且优先于构造函数执行。
构造代码块和构造函数的区别:
构造代码块中定义的是不同对象共性的初始化内容,给所有对象进行统一初始化;而构造函数是给对应的对象初始化。
例:
class PersonTest
{
String name;
int age;
//构造代码块
{
System.out.println("构造代码块运行");
}
//无参数的构造函数
PersonTest()
{
System.out.println("无参数的构造函数运行");
}
//有一个参数的构造函数
PersonTest(String name)
{
System.out.println("有一个参数的构造函数运行");
}
}
class PersonTestDemo
{
public static void main(String[] args)
{
System.out.println("下面是建立第一个对象p1后的运行结果:");
PersonTest p1 = new PersonTest();
System.out.println();
System.out.println("下面是建立第二个对象p2后的运行结果:");
PersonTest p2 = new PersonTest("zhangsan");
}
}
编译后运行结果如下:
通过运行结果可以看出,每次创建好对象后,构造代码块中的内容都会被执行;而重载的其他构造函数,是在其所属的对象被创建时,才开始执行。
第二讲 this关键字
1、this关键字用于区分局部变量和成员变量同名情况。
this代表它所在函数所属对象的引用,简单地说,哪个对象在调用this所在的函数,this就代表哪个对象。
This关键字的应用:当定义类中功能(方法)时,并且该函数内部要用到调用该函数的对象,这时用this来表示这个对象。通俗的说就是,只要本类功能内部使用了本类对象,就用this关键字进行区分。
例:class Person
{
String name; //定义成员变量(实例变量)
int age;
Person(String name,int age) //定义构造函数
{
this.name=name; //此处的this用于区分成员变量和局部变量
this.age=age; //此处的this用于区分成员变量和局部变量
}
public boolean Compare(Person p)
{
return this.age==p.age; //此处的this表示调用该函数的对象
}
}
class ThisDemo
{
public static void main(String[] args)
{
Person p1=new Person("zhangsan",30); //定义对象p1
Person p2=new Person("lisi",36); //定义对象p2
boolean b=p1.Compare(p2); //p1调用Compare函数,并把对象p2作为参数传递给Compare函数
//输出结果
if(b)
System.out.println(p1.name+"与"+p2.name+"年龄相等");
else
System.out.println(p1.name+"与"+p2.name+"年龄不相等");
}
}
2、this语句用于构造函数之间进行互相调用。
this语句只能定义在构造函数的第一行,因为初始化要先执行。并且this()不能用用在一般函数中,只能用在构造函数间。
class Person
{
String name; //定义成员变量
int age;
Person() //构造方法
{
System.out.println("this()语句被执行"); //判断this()语句是否执行
}
Person(String name) //构造方法
{
this(); //this语句只能放在构造函数的第一行
this.name=name;
System.out.println("在创建对象时this(name)语句被执行,"+"这里的this是"+this.name+"所属的对象");
//判断this(name)语句是否执行
}
Person(String name,int age) //构造方法
{
this(name); //this语句只能放在构造函数的第一行,调用构造函数
this.name=name;
this.age=age; //此处this为关键字,表示调用该函数的对象,用于区分成员变量和局部变量
System.out.println("我叫"+this.name+"我的年龄是"+this.age);
System.out.println();
}
}
class ThisDemo2
{
public static void main(String[] args) //主函数
{
Person p = new Person("zhangsan",30); //创建对象
Person p1 = new Person("lisi",36);
}
}
此程序运行结果如下图所示:
通过运行结果可以看出,this语句用在构造方法之间的相互调用;this关键字表示调用this所在函数的所属对象,用于区分局部变量和成员变量。
第三讲 静态
静态static的特点:
1、随着类的加载而加载;
2、被所有对象共享;
3、优先于对象存在;(比对象早开辟内存空间)
4、可以被类名直接调用;(类名.静态成员)
实例变量(成员变量)和类变量(静态的成员变量)的区别:
1、存放位置不同
类变量随着类的加载而在方法区(数据区或共享区)中开辟内存空间。
实例变量则随着对象的建立而存在于堆内存中。
2、生命周期不同
类变量的生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态方法的使用注意事项:
1、静态方法只能访问静态方法;
2、静态方法中不能定义this和super关键字;(因为静态是先于对象存在的,所以静态方法中不可以出现this关键字)
3、main方法是静态方法,所以调用其它方法有两种方式:一是通过创建对象,用对象调用非静态的方法;二是直接调用静态方法。
例:
class MainDemo2
{
public static void main(String[] args)
{
MainDemo2 T = new MainDemo2(); //创建对象
T.Print(); //用对象调用非静态方法
MainTest.Test(); //直接调用静态方法
}
public void Print()
{
System.out.println("在main方法中用对象调用非静态的方法");
}
}
class MainTest
{
public static void Test()
{
System.out.println("在Main方法中直接调用静态方法");
}
}
什么时候定义静态变量(类变量)?
答:当对象中出现共享数据时,该数据被静态所修饰。
什么时候定义静态函数?
答:当功能内部没有访问到非静态数据时,那么该功能就可以定义成静态的。
例1:
class Person
{
String name;
public static spesk() //函数中没有访问非静态数据的语句,所以可以直接定义成静态的方法
{
System.out.println("Hello!");
}
}
class Test
{
public static void main(String[] args)
{
Person p =new Person(); //创建对象
p.speak(); //用对象调用静态方法
Person.speak(); //直接调用静态方法,相当于上面的两句
}
}
例2:
class Person {
String name;
Person(String name)
{
this.name=name;
}
public void speak() //函数中有访问非静态数据的语句,所以不能定义成静态的方法
{
System.out.println("Hello!"+name); //name为非静态成员
}
}
class Test
{
public static void main(String[] args)
{
Person p =new Person("zhangsan"); //创建对象
p.speak(); //只能用对象调用该方法,不能直接调用该方法
}
}
静态有利有弊:
利处:对对象的共享数据进行单独空间的存储,没有必要每一个对象中都存储一份,从而节省内存空间;另外,静态成员(包括成员变量和成员方法)可以直接被类名调用,使代码更简洁。
弊端:1、生命周期过长,容易产生内存垃圾;2、静态只能访问静态,从而使访问出现局限性。
静态代码快:用于给类进行初始化。
格式:
static
{
静态代码块中的执行语句。
}
静态代码块的特点:随着类的加载而执行,只执行一次,并优先于主函数执行。
这个特点可以通过下面的例子看出:
class StaticCode
{
//静态代码块
static
{
System.out.println("c");
}
}
class StaticCodeDemo
{
//因为运行的是主函数所在的类,所以先执行本函数中的静态代码块。
static
{
System.out.println("a");
}
public static void main(String[] args)
{
new StaticCode(); //打印a
new StaticCode(); //不再打印a,因为第一次类StaticCode加载时已经开辟内存空间,不需要重复开辟。
System.out.println("over");
}
static
{
System.out.println("b");
}
}
编译执行的输出顺序为:a,b,c,over,运行结果截图如下:
以上是我通过学习传智播客毕向东老师的视频教程后,自己做的笔记和总结,如有不当之处,请各位大神多多指教!!