2018.3.29
构造方法
构造方法的功能：初始化类对象！！！给成员变量进赋值操作。
格式：
修饰符 类名（用于初始化的参数列表） {
//初始化语句体
}构造方法的注意细节：
1.构造方法作用:(1).构造出来一个类的实例 (2).对构造出来一个类的实例(对象)初始化。
2.构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。
3.主要完成对象的初始化工作，构造方法的调用是在创建一个对象时使用new操作进行的。
4.类中必定有构造方法，若不写，系统自动添加无参构造方法。接口不允许被实例化，所以接口中没有构造方法。
5.不能被static、final、synchronized、abstract和native修饰。
6.构造方法在初始化对象时自动执行,一般不能显式地直接调用.当同一个类存在多个构造方法时，java编译系统会自动按照初始化时最后面括号的参数个数以及参数类型 来自动一一对应。完成构造函数的调用。
7.构造方法分为两种:无参构造方法 有参构造方法
构造方法可以被重载。没有参数的构造方法称为默认构造方法，与一般的方法一样，构造方法可以进行任何活动，但是经常将他设计为进行各种初始化活动，比如初始化对象的属性。
8.构造代码块:
(1)作用:给对象进行初始化，对象一建立就执行，而且优先于构造函数执行
(2)构造代码块和构造函数的区别:
构造代码块是给所有不同对象的共性进行统一初始化，构造函数是给对应的对象进行初始化
9.子类继承父类中，
***子类的实例化过程
***构造方法不能被子类继承
***子类创建对象时，会先去创建父类的对象。
默认是去调用父类的无参构造方法。
***子类构造方法中，第一行默认是super()
为什么子类中第一行会默认有super()?
因为他继承父类的成员使用，使用前这些成员必须初始化，
而他们是父类的成员，所以，必须通过父类进行初始化。
所以，会先创建一个父类的对象。
**当父类没有无参构造方法时
必须使用this或者super调用其他的构造方法。
10.自定义类中，如果不写构造方法，java系统会默认添加一个无参的构造方法。如果写了一个有参的构造方法，就一定要写无参构造方法。
如果想使用无参的构造方法，就必须手动给出无参构造方法。
建议:一般情况下，我们自定义的类都要手动给出无参构造方法。构造方法和成员方法区别
---|---
| 区别 | 构造方法 | 成员方法 |
|---|---|---|
| 返回值 | 构造没有返回值，也不需要void填充 | 有，如果确实没有返回值也要用void填充 |
| 方法名 | 构造方法的名字是类名，不能其他名字 | 随便，符合规范见名知意动 |
| 作用区别 | 构造方法是用来初始化对象的，通过new调用 | 是对类对象的行为描述，也是完成某些特定的区别 |
| 调用者区别 | 构造方法的真实的使用者是JVM，通过new关键字使用构造方法 | 目前是使用对象来调用的后面会有使用【类名】来调用 |
class Baby {
//成员变量
private String name;
private int id;
//可以自定义一个无参构造方法，提供给调用者使用
//实现一个有参数的构造方法
//两个参数
//为了符合实际情况，可以存在多种构造方法，初始化成员变量不一样。
//函数名一样，参数名不一样 java支持参数的重载，节省函数的定义。
public Baby() {
System.out.println("无参数的构造方法");
}
public Baby(String n) {
//这里只初始化了name属性Field(字段)
name = n;
System.out.println("初始化name属性的构造方法");
}
public Baby(int i) {
//这里只是初始化了ID属性
id = i ;
System.out.println("初始化id属性的构造方法");
}
public Baby(String n ,int i) {
name = n;
id =i;
System.out.println("初始化两个参数的构造方法");
}
public void setName(String n ) {
name = n;
}
public String getName() {
return name;
}
public void setId(int i) {
id = i;
}
public int getId() {
return id;
}
//成员方法
public void cry() {
System.out.print("哭");
}
public void sleep() {
System.out.print("睡");
}
}
public class Demo2 {
public static void main(String[] args) {
// 發現調用了一個無參的變量
Baby b = new Baby();
Baby b2 = new Baby("1",12);
Baby b3 = new Baby(12);
}
}成员变量赋值优先级
在java中，有三种对于成员变量进行赋初值的操作；
1.定义时初始化
2.构造代码块
3.构造函数 优先级最高
优先级问题：
如果在代码中存在构造方法，那么成员变量的最终值和构造方法有关。
如果只有构造代码块和定义时初始化，谁在后谁是最终值。
class Test {
public Test() {
num = 3000;
}
{
num = 2000;
}
int num = 1000;
}
public class Demo4 {
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.num);//1000 2000 3000
}
}构造代码块
/*
小孩子出生就得哭，被动。
【要求】
小孩子出生，创建对象之后必须得哭。
【问题】
现行的处理方式，不符合生活逻辑，是对象创建完之后调用cry（）方法完成，但是我们期望的是对象和cry方法是同时的。
【瓶颈】
目前处理方式是将cay方法放到每一个构造方法中，通过调用构造方法，创建并初始化对象，同时调用cry（）方法，的确可以
解决问题。
极端情况 若有非常多构造方法，但是每一个构造方法都要有cry（）方法。
【解决方案】
构造代码块！
{
//执行的代码（100%执行的）
}
作用：
不管是通过调用哪一个该类的构造方法来初始化对象，都会自动执行构造代码块里面的代码
等于说构造代码块里面的代码会对【当前类所有的对象】进行初始化操作。
要求：
构造代码块放在成员变量之后，构造方法之前。、
代码块：
1.构造代码块
2.局部代码块（基本不用）
3.静态代码块（后期用的多 static JDBC（java数据库连接））
*/
class Person {
private String name;
private int id;
//构造代码块！
{
cry();
}
public Person() {
System.out.println("无参数的构造方法");
}
public Person(String n) {
//这里只初始化了name属性Field(字段)
name = n;
System.out.println("初始化name属性的构造方法");
}
public Person(int i) {
//这里只是初始化了ID属性
id = i ;
System.out.println("初始化id属性的构造方法");
}
public Person(String n ,int i) {
name = n;
id =i;
System.out.println("初始化两个参数的构造方法");
}
public void setName(String n ) {
name = n;
}
public String getName() {
return name;
}
public void setId(int i) {
id = i;
}
public int getId() {
return id;
}
//成员方法
public void cry() {
System.out.println("哭");
}
public void sleep() {
System.out.println("睡");
}
}
public class Demo3 {
public static void main(String[] args) {
Person b = new Person();
}
}函数重载
【知识点】
函数/方法的重载：
前提条件：在同一个类内 不能夸类。
必须条件：同一个函数/方法名。
不同条件：参数类型和参数数量不同，还有返回值不同
总结：
重载就是在同一个类当中，同名函数/方法，但是参数，返回值可以不同，这叫做函数/方法的重载。
这样使用可以减少代码的复杂度，减少函数名的使用。
反编译工具：javap javapthis关键字
this字面含义 这儿！ 这个！
代码中：表示调用该方法的对象
在Eclipse自动生成的Setter和Getter方法中，我们发现，Eclipse会使用this关键字来区分
成员变量还是参数列表，而且形式参数名字和成员变量的名字一致。
setter和getter方法，都是通过当前【类的对象】来调用的，而这个this表示的就是调用该方法的【类对象】。
java中规定，哪一个对象调用这个方法，哪一个对象就是this【80%严谨】
this关键字的作用：
1.解决就就近原则，在java中如果存在成员变量和局部变量的名字是一致的，就可以通过this来约束条件，用this.成员变量名
来区分到底是成员变量还是局部变量。
2.this可以在类内来调用其他方法，this.方法名（参数）【80%严谨】
class Dog {
//成员变量
private String name;
private String color;
private int age;
//构造方法
public Dog() {
}
public Dog(String name,String color,int age) {
this.name=name;
this.color=color;
this.age=age;
//打印this,打印的结果是一个【包名.类名@地址】
System.out.println("line30:"+this);
}
//setter和getter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
System.out.println("line39:"+this);
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Demo5 {
public static void main(String[] args) {
Dog dog = new Dog("doudou","三花",7);
dog.setName("爸爸");
//展示当前对象的地址
System.out.println("line64："+dog);
/*
* 这里不管是30 还是39行 打印结果都是day10.Dog@62bc184
* 证明这些用到this或者对象本身的地方都是同一个对象。
* */
}
}
this关键字的特殊用法【难点】
this关键字可以调用成员变量，可以使用成员方法，都是通过 "."运算符来调用的。
this关键字调用构造方法的格式：
this(实际参数列表)；
通过this关键字来调用方法
this(实际参数)
class Cat {
//成员变量
private int age;
private String name;
/*通过this关键字来调用方法
this(实际参数)
用this关键字调用构造方法的注意事项：
1.参数类型，参数的顺序，参数的数量要和构造方法中一一对应，这样java编辑器才能知道
到底调用的哪一个构造方法，这里采用方式是【函数/方法的重载】
2.在一个构造方法中通过this关键字调用另一个构造方法，那么这条语句必须在当前代码块的第一行
3.两个构造方法不能通过this关键字相互调用 。
*/
public Cat(){
this(10);//重载的话根据类型匹配
//this("瓜皮");
}
//初始化name的构造方法，参数类型是String
public Cat(String name) {
this.name = name;
}
//初始化age的构造方法，参数类型是int
public Cat(int age) {
this.age = age;
//this（）；
}
//初始化age,name的构造方法，参数类型是int,String
public Cat(int age,String name) {
this.age = age;
this.name = name ;
}
//setter和getter方法。
public void setAge(int age) {
if(age<0||age>20) {
this.age = age;}
this.age = 0;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
扫一扫
431
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
