构造方法,this,super,final,static
1构造方法
一个Person类,属性都被private了,外界无法直接访问属性,必须对外提供相应的set和get方法。但如果需要在创建对象的同时明确对象的属性值,就需要构造方法了。
1.1定义
构建创造时用的方法,即就是对象创建时要执行的方法。
格式:
修饰符 构造方法名(参数列表)
{
}
1.2特点
1)构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的,对象创建完,方法就执行结束。
2)构造方法没有具体的返回值。
3)构造方法名称必须和类名保持一致。
这就可以解释了,创建对象时,要加一个扩号,这不就是在调用方法嘛,
Person p=new Person();
例:
public class Person {
private String name;
private int age; public Person(String name, int age) {
super();
this.name = name;
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
Person p2=new Person("张三",18);
System.out.println(p2.getName());
System.out.println(p2.getAge());
}
}
1.3内存图
步骤解释:
1 main方法进栈
2在堆中开内存,赋初值
3有参构造方法进栈
4传参,赋值
5有参构造弹栈
6地址赋值给p2
7 getname进栈,通过地址找到name,打印
8 getage进栈,通过地址找到age,打印
1.4默认构造方法
编译器在编译java文件时,如果发现类中没有构造方法,会自动添加一个空参构造。
但如果类中只要有一个构造方法,则不会自动添加空参构造了。
如果写了有参构造方法,那么new对象时,再用空参的就会报错。
所以如果写了有参构造,最好把空参构造也加上。因为使用空参构造的情况更多。有参构造用的比较少,一般测试时用。
当描述的事物在创建其对象时就要明确属性的值,就用有参的
若创建对象时不需要明确具体的数据,可以不用写构造方法,因为会自动加默认的空参构造方法。
还是上面的例子,因为Person定义了有参,所以test再调用空参就会报错:
1.5注意的细节
1)一个类中可以有多个构造方法,(空参、部分成员变量是参数、全部成员变量都是参数)这其实是方法重载。
2)构造方法可以被private修饰,这样其他程序无法创建该类的对象了。
如果类比较重要,就可以这样,构造方法用private修饰,不让创建对象。
其他方法可以用static修饰,那么就可以直接用类.方法,这样调用了。
例如System类,就是这样的,
在eclipse中,在类上面,ctrl+点击该类,可以查看源码:
1.6构造方法和一般方法区别
构造方法在对象创建时就执行了,而且只执行一次。
一般方法是在对象创建后,需要使用时才被对象调用,并可以被多次调用。
对象在创建之后需要修改和访问相应的属性值时,在这时只能通过set..或者get..方法来操作。
所以构造方法可以不写,get set必须写
例:
class Person {
void Person() {
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
}
}
这段代码的Person前面有返回值,所以不是构造方法,那么就会自动添加一个空参构造。所以代码是可以运行的,可以new对象的。但是不建议这样写,可以看到在eclipse中出现警告:
2 this关键字
之前用this可以解决成员变量和局部变量同名的问题。
this代表的是对象,哪个对象调用了this所在的方法,this就代表哪个对象。
this还可以用于在本类中构造方法之间的调用。
2.1格式:
this(参数列表);
注意:只能构造方法里用this(),普通方法里不能用this()。
例:
public class Person {
private String name;
private int age; public Person(){
//调用本类构造方法
this("李小华",19);
} public Person(String name,int age){
this.name=name;
this.age=age;
} public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
Person p1=new Person();
System.out.println(p1.getName());
System.out.println(p1.getAge()); Person p2=new Person("张小美",18);
System.out.println(p2.getName());
System.out.println(p2.getAge());
}
}
这里的this("李小华",19);
相当于:
但是,this必须写在第一行,如果这样,是不行的
原因是初始化动作要最先执行。
2.2内存图
步骤解释:
1main进栈,看到new,堆中开内存,属性赋初值
2空参进栈
3找第一个参数是name,age的构造方法,进栈,并把参数传过去
4赋值
5有参构造弹栈,空参构造弹栈
6地址赋给p
7getName进栈,打印,getAge进栈,打印
例:判断两个人是否是同龄人
(之前代码)
3 super关键字
3.1可以用于子父类中构造方法的调用
例:
public class Person {
public Person(){
System.out.println("这是父类构造方法");
}
}
public class Student extends Person{
public Student(){
System.out.println("这是子类构造方法");
}
}
public class Test {
public static void main(String[] args) {
Student s=new Student();
}
}
为什么会这样呢?因为在创建子类对象时,父类的构造方法会先执行,
子类中所有构造方法的第一行有默认的隐式super();语句。
格式:
调用本类中的构造方法
this(实参列表);
调用父类中的空参数构造方法
super();
调用父类中的有参数构造方法
super(实参列表);
3.2 但是,如果父类定义了有参构造,那么子类则必须调用super(参数),必须手动写上。
因为父类不会自动创建空参构造了,所以子类的super()就找不到了。
public class Person {
public Person(String name){
System.out.println("这是父类构造方法");
}
}
改成这样就可以了:
所以一个类只要定义了有参构造,一定再写一个空参构造,因为有可能被继承,不写会导致子类报错。
3.3为什么子类对象创建都要访问父类中的构造方法
例:
public class Person {
int a=1;
public Person(String name){
a=5;
System.out.println("这是父类构造方法");
}
}
public class Student extends Person{
public Student(){
super("张三");
System.out.println("这是子类构造方法");
}
}
public class Test {
public static void main(String[] args) {
Student s=new Student();
System.out.println(s.a);
}
}
这里Student是Person的子类,因为Person中在构造方法改变了成员变量的值,所以如果Student不访问Person的构造方法,那么就得不到Person中真正的成员变量的值了,也就不是真的继承了。
总结:
子类会继承父类中的内容,所以子类在初始化时,必须先到父类中去执行父类的初始化动作。这样,才可以使用父类中的内容。
子父类是会一级一级的调用的,最终是object。
3.4如果有this()
如果子类的构造方法第一行写了this调用了本类其他构造方法,那么super调用父类的语句就没有了。因为this()或者super(),只能定义在构造方法的第一行,因为初始化动作要先执行。
例:
public class Animal {
public Animal(int age){
}
}
这里写了this(),那么意思就是调用的下面的那个有参构造,而这里面有super,所以,上面就不能再写super了,会报错。
3.5总结:
1)如果有this();那么就不会有super();了。不写也不会自动加了。
2)构造方法只要直接或间接可以调用父类构造方法就可以。
3)this和super都是只能在构造方法中使用
在eclipse中也可以有构造方法的快捷方式:
右键--source--Generate Constructor using Fields
可以点任意个,一个不选,就是空参构造。
可以看到,点出来后,第一行就是super();
3.6 super练习
描述学生和工人这两个类,将他们的共性name和age抽取出来存放在父类中,并提供相应的get和set方法,同时需要在创建学生和工人对象就必须明确姓名和年龄。
public class Person {
private String name;
private int age; public Person(String name, int age) {
super();
this.name = name;
this.age = age;
} public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Student extends Person{
public Student(String name, int age) {
super(name, age);
}
}
public class Worker extends Person{
public Worker(String name, int age) {
super(name, age);
}
}
public class Test {
public static void main(String[] args) {
Student s=new Student("小红帽",18);
System.out.println(s.getName());
System.out.println(s.getAge()); Worker w=new Worker("大灰",81);
System.out.println(w.getName());
System.out.println(w.getAge());
}
}
super通常是这么用的,父类的构造方法既可以给自己的对象初始化,也可以给自己的子类对象初始化。
总结:
this的三个作用:
解决成员变量和局部变量同名问题
代表本类对象,调用本类中的变量和方法
构造方法之间的调用
super的两个作用:
代表父类对象,调用父类的变量和方法
子父类中构造方法的调用
4 final关键字
有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。这时需要使用关键字final,final的意思为最终,不可变。final是个修饰符,可以用来修饰类,类的成员,以及局部变量。不能修饰构造方法。
4.1 final修饰类
final修饰类不可以被继承,但是可以继承其他类(也叫太监类)
例:
public class Person {
} public final class Father extends Person{
}
这里的father就不能被继承了。
4.2 final修饰方法
final修饰的方法不可以被子类重写,但父类中没有被final修饰方法,子类重写后可以加final。(也叫太监方法)
例:
public final class Father{
public final void method1(){
}
public void method2(){
}
}
public class Son extends Father{
public final void method2(){
}
}
这里son可以重写method2,不能重写method1
4.3 Final修饰局部变量
1)局部变量是基本数据类型(称为常量):一旦赋值,终身不变
2)局部变量是引用数据类型:一旦赋值一个地址,终身不变。但是地址内的对象属性值可以修改。
4.4 Final修饰成员变量
必须手动赋值或构造方法赋值。因为成员变量有默认值null,不赋值就终身是null了。
只要在分配地址之前(也就是创建对象之前)赋值就可以。
例:
这样才可以:
或这样:
public class Person {
final String name2;
public Person(String name2){
this.name2=name2;
}
}
5 static关键字
被static修饰的成员变量属于类,不属于这个类的某个对象。
被static修饰后就共享了(有一个改变,就全变了)。
5.1例:
public class Student {
private String name;
private String schoolname; public Student() { } public Student(String name, String schoolname) {
this.name = name;
this.schoolname = schoolname;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getSchoolname() {
return schoolname;
} public void setSchoolname(String schoolname) {
this.schoolname = schoolname;
}
}
public class Test {
public static void main(String[] args) {
Student s1=new Student("小红","清华大学");
Student s2=new Student("小明","清华大学");
Student s3=new Student("小亮","清华大学");
s2.setSchoolname("北京大学"); System.out.println(s1.getSchoolname());
System.out.println(s2.getSchoolname());
System.out.println(s3.getSchoolname());
}
}
说明schoolname是属于每一个对象的
改:private static String schoolname;
这时schoolname是共享的了,是属于Student类的了。
5.2内存图
(数据共享区也叫 静态区)
内存图步骤说明:
1 test.class进共享区,扫描到main,student.class,也进入
2因为main是static,所以main进静态区
3扫描student.class,有static的schoolname,就进静态区,并赋值初始值null
4 main方法进栈
5 有new,就在堆中开内存,找到属性 name赋值null(这时不会再找schoolname了,因为已经在静态区了)
6 分配地址
7 构造方法进栈,传值:小红,清华大学
8 this.name,找到地址,然后找到name,赋值小红
9 根据地址去静态区找schoolname(这里应该用类.变量才对,但是用对象.变量还是能找到的)静态区的schoolname被改值为清华大学
10构造方法弹栈
11 地址赋值给s1
12 s2的new,s3的new,过程是一样的...
13 执行到s2.setSchoolname("北京大学")这一步时,静态区schoolname被改成北京大学
14 后面System.out.println访问的就全是北京大学了
5.3 Static特点
1)属于类,不属于对象
如果一个对象将static成员变量值进行了修改,其他对象的也跟着变,就是共享一个。
2)通过类名直接调用,不建议用对象调用(会有警告)
这样就可以:
5.4注意的地方
1)不能用this和super调用(因为this代表本类对象,super代表父类对象,但是被static后已经不属于对象了)
2)静态内容是优先于对象存在,只能访问静态
3)同一个类中,静态成员只能访问静态成员,不能访问非静态
简单记:
非静态可以调静态
静态不能调非静态
因为static是进共享区的,所以可以理解为先有static show2,后有age,所以在show2中找不到age。
这也解释了,一个类中有main方法时,其他方法必须加static,才可以调用。
这里的methods();其实写全了,是Test.methods();
如果方法不加static,就得new一个test对象,来调用(因为对象能调用变量和方法)
5.5特殊的地方
1)main方法是特殊的,main方法为静态方法仅仅为程序执行入口,它不属于任何一个对象,可以定义在任意类中。main是虚拟机调用。
2)多态中也有特殊:
多态调用方法中,编译看左边,父类有,编译成功,父类没有,编译失败
运行静态方法,运行父类中的静态方法,
运行非静态方法,运行子类的重写方法(因为静态了,就属于类了)
成员变量,编译运行全是父类
例:
public class Father {
static int i=1;
public static void f(){
System.out.println("这是父类静态方法");
}
}
public class Son extends Father{
static int i=2;
public static void f(){
System.out.println("这是子类重写后的静态方法");
}
}
public class Test {
public static void main(String[] args) {
Father f=new Son();
System.out.println(f.i);
f.f();
}
}
5.6定义静态常量
静态常量一旦赋值,终身不变。可以类.变量名调用。
5.6.1定义格式:
public static final 数据类型 变量名 = 值;
(这里不一定非要Public,也可以私有,但是没意义,所以都是public)
5.6.2规则
static写final前面,
变量名全部大写,多个单词使用下划线连接。
例:public static final String SCHOOL_NAME = "北京大学";
Math.PI也是静态常量
5.6.3接口中的每个成员变量都默认使用 public static final 修饰。
所有接口中的成员变量已是静态常量,由于接口没有构造方法,所以必须显示赋值。可以直接用接口名访问。(因为用final定义的成员变量必须赋值)
最新文章
- 带你玩转JavaWeb开发之四 -如何用JS做登录注册页面校验
- java API:AtomicInteger
- java多线程系类:基础篇:10生产者消费者的问题
- 讲解JS的promise,这篇是专业认真的!
- redis_查找命令
- sql中更新数据库用到declare @a in
- Spring PecClinic宠物医院---安装
- win7搭建php7+apache2.4
- HTML5获取当前的经纬度坐标
- 以Kafka Connect作为实时数据集成平台的基础架构有什么优势?
- echarts 调整图表大小的方法
- python(九)迭代器和生成器
- 二十三. Python基础(23)--经典类和新式类
- SQL Server的一个不显眼的功能 备份文件的分割
- 自学Zabbix4.1 zabbix监控web服务器访问性能
- golang语言中sync/atomic包的学习与使用
- 23种设计模式(1)-Facade设计模式
- POJO与PO、VO的区别
- [整理]C结构实现位段(bit field)
- 【转】教你用C#读写、删除、更新excel表格记录
热门文章
- git push -u origin master error: failed to push some refs to
- freemaker宏的用法
- WPF后台修改内容界面不显示问题
- zookeeper原理与实践(一)----zookeeper的基本功能
- 转换嵌套JSON数据为TABLE
- 文本情感分析(一):基于词袋模型(VSM、LSA、n-gram)的文本表示
- ansible无网络安装openstack(Newton)
- Git查询
- PAT甲级真题及训练集
- Object Detection(RCNN, SPPNet, Fast RCNN, Faster RCNN, YOLO v1)