实例初始化
类的提取:
名词提取法，转换为现实世界中的事物的类别==》计算机程序中的类
类的设计: .
类的成员的设计
5大成员(5大组成部分) :
1、属性:数据特征
2、方法:行为特征，功能特征
3、构造器:创建对象时用
类的第三个组成部分 : 构造器，也称为构造方法，因为 (1) 它长的像方法
(2) 它编译后是一个实例初始化方法
1、构造器的作用
(1)构造对象，创建对象
和 new 一起使用，每次调用它就是在创建新的对象
2、构造器的特点
(1)所有类都有构造器
(2)如果一个类没有显式声明构造器，那么编译器将会自动生成一个默认的无参构造
(3)如果一个类显式声明了构造器，那么编译器将不会自动生成默认的无参构造了
(4)构造器的名称必须与类名相同
(5)构造器没有返回值类型，也不写void
(6)构造器可以重载
3、构造器的语法结构
[修饰符] 类名(){
[修饰符]类名 (形参列表) {
}
4、代码块:在类初始化和对象初始化时用的
5、内部类:在某个大的事物中，包含了一个独立的小的事物类别，而且一般这个小的事物只为大的事物服务时。
(4)代码块
①非静态代码块
②静态代码块:后面讲，和static一起
2、非静态代码块
声明的格式:
[修饰符] class类名{
{
非静态代码块;
}
(2)非静态代码块中的代码什么时候执行?
①在“每次”创建对象的时候执行
②比构造器早
(3)实例初始化过程：创建对象时，为对象进行初始化的操作
①为成员变量显式赋值
②执行非静态代码块
③执行构造器
public class TestBlock {
public static void main(String[] args) {
MyClass my1 = new MyClass(); //调用无参构造
MyClass my2 = new MyClass("atguigu"); //调用有参构造
}
}
class MyClass {
private String str ="hello"; //显示赋值;
public MyClass() {
System.out.println("无参构造");
}
public MyClass(String str) {
this.str = str;
System.out.println("有参构造");
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
{
System.out.println("非静态代码块");
}
}
Java编译器其实，会把这三个部分的代码，合成一个叫做( [形参列表] )实例初始化方法
即编译后的.class字节码信息中，是没有构造器这个概念。
( [形参列表] )实例初始化方法的代码就是由三个部分组成:
①成员变量显式赋值的代码
②非静态代码块中的代码
③构造器中的代码
其中的①和②按顺序执行，而③-定是它们当中的最后执行。
而且，有几个构造器，就会有几个实例初始化方法，那么当你创建对象的时候，调用对应的构造器时，其实执行的是对应的实例初始化方法( […])
package Day10;
public class TestBlock {
public static void main(String[] args) {
MyClass my1 = new MyClass(); //调用无参构造
MyClass my2 = new MyClass("atguigu"); //调用有参构造
}
}
class MyClass {
{
System.out.println("非静态代码块 ①");
}
private String str =assign();//显示赋值
public MyClass() {
System.out.println("无参构造");
}
public MyClass(String str) {
this.str = str;
System.out.println("有参构造");
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
{
System.out.println("非静态代码块 ②");
}
public String assign(){
System.out.println("assign方法");
return "hello";
}
}
.class文件反编译得到的数据中有的字段（底层没有构造器的概念，只要实例初始化方法）
大致简化为：
class MyClass {
private String str;
// 无参的实例初始化方法
<init>() {
System. out. print1n("非静态代码块1");
str = assign();//调用方法,来为str进行显式赋值
System.out.println(“非静态代码块2") ;
System.out.print1n("无参构造“);
}
// 有参的实例初始化方法
<init>(String str) {
System.out.println("非静态代码块1"):
str = assign();//调用方法,来为str进行显式赋值
System.out.println("非静态代码块2" ) ;
this.str = str;
System.out.println("有参构造" ) ;
}
public String assign() {
Syst em. out. println(" assign方法^ );
return "hello" ;
}
}
构造器的易错点：
package Day10;
public class TestInit {
public static void main(String[] args) {
Son s = new Son();
}
}
class Father {
public Father() {
System.out.println("父类的无参构造器");
}
}
class Son extends Father {
public Son() {
//隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
System.out.println("子类的无参构造器");
}
package Day10;
public class TestInit {
public static void main(String[] args) {
Son s = new Son();
Son s2 = new Son("hello");
}
}
class Father {
public Father() {
System.out.println("父类的无参构造器");
}
}
class Son extends Father {
private String str;
public Son() {
//隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
System.out.println("子类的无参构造器");
}
public Son(String str) {
this.str = str;
System.out.println("子类的有参构造器");
}
}
package Day10;
public class TestInit {
public static void main(String[] args) {
Son s = new Son();
Son s2 = new Son("hello");
Son s3 = new Son("ahello",2);
}
}
class Father {
public Father() {
System.out.println("父类的无参构造器");
}
}
class Son extends Father {
private String str;
private int num;
public Son() {
//隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
System.out.println("子类的无参构造器");
}
public Son(String str) {
this.str = str;
System.out.println("子类的有参构造器1");
}
public Son(String str,int num) {
this(str);
this.num =num;
System.out.println("子类的有参构造器2");
}
}
package Day10;
/*
*
*(1)先执行父类的实例初始化方法
`它由三部分:
` ①成员变量的显式赋值
②非静态代码块
③构造器
(2)再执行子类的实例初始化方法
它由三部分:
①成员变量的显式赋值
②非静态代码块
③构造器
super( )或super(实参列表)之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法
super( )或super(实例列表)之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行
* */
public class TestInit2 {
public static void main(String[] args) {
Zi z =new Zi();
}
}
class Fu{
{
System.out.println("1 父类的非静态代码块") ;
}
public Fu() {
System.out.println("2 父类的无参构造");
}
}
class Zi extends Fu{
{
System.out.println("3 子类的非静态代码块");
}
public Zi() {
// super( ) == >调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
System.out.println("4 子类的无参构造");
}
}
package Day10;
/*
*
*(1)先执行父类的实例初始化方法
`它由三部分:
` ①成员变量的显式赋值
②非静态代码块
③构造器
(2)再执行子类的实例初始化方法
它由三部分:
①成员变量的显式赋值
②非静态代码块
③构造器
super( )或super(实参列表)之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法
super( )或super(实例列表)之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行
* */
public class TestInit2 {
public static void main(String[] args) {
Zi z =new Zi();
}
}
class Fu{
private String strFu =assignFu();
{
System.out.println("1 父类的非静态代码块") ;
}
public Fu() {
System.out.println("2 父类的无参构造");
}
public String assignFu(){
System.out.println("3 父类的assign()");
return "fu";
}
}
class Zi extends Fu {
private String strZi =assignZi();
{
System.out.println("4 子类的非静态代码块");
}
public Zi() {
// super( ) == >调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
System.out.println("5 子类的无参构造");
}
public String assignZi(){
System.out.println("6 子类的assign()");
return "zi";
}
}
package Day10;
public class TestInit3 {
public static void main(String[] args) {
Er r = new Er();
}
}
class Ba{
private String str =assign();
{
System.out.println("1 父类的非静态代码块") ;
}
public Ba() {
System.out.println("2 父类的无参构造");
}
public String assign(){
System.out.println("3 父类的assign()");
return "bs";
}
}
class Er extends Ba {
private String str =assign();
{
System.out.println("4 子类的非静态代码块");
}
public Er() {
// super( ) == >调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
System.out.println("5 子类的无参构造");
}
public String assign(){
System.out.println("6 子类的assign()");
return "er";
}
}
初始化分析：
