面向对象---类(类/实例初始化）

最新推荐文章于 2023-06-17 22:09:20 发布

d-isease

最新推荐文章于 2023-06-17 22:09:20 发布

阅读量420

点赞数

分类专栏： JAVA JAVA笔记文章标签： java 类

本文链接：https://blog.csdn.net/m0_45302724/article/details/107248420

版权

JAVA 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

JAVA笔记

5 篇文章 0 订阅

订阅专栏

1、类的成员：

（1）属性：成员变量
（2）方法：成员方法
（3）构造器
（4）代码块
①非静态代码块
②静态代码块：static
2、非静态代码块
（1）声明的格式
【修饰符】 class 类名{
```
   {
```
```
   非静态代码块；
```
```
   }
```
}
(2)非静态代码块在声明时候执行？
在创建对象的时候执行
比构造器先早

public class TestBlock {
	public static void main(String[] args){
		MyClass my = new MyClass();//调用无参构造
	}

}
 class MyClass{
	 public MyClass(){
		 System.out.println("无参构造");
	 }
	 {
		 System.out.println("这是非静态代码块");
	 }
 }

结果为：
这是非静态代码块
无参构造

在每次创建对象时都执行

public class TestBlock {
	public static void main(String[] args){
		MyClass my = new MyClass();//调用无参构造
		MyClass my2 = new MyClass("jkworld");//调用有参构造
	}

}
 class MyClass{
	 private String str;
	 
	 public MyClass(){
		 System.out.println("无参构造");
	 }
	 public MyClass(String str){
		 this.str=str;
		 System.out.println("有参构造");
	 }
	 {
		 System.out.println("这是非静态代码块");
	 }
 }

结果为：
这是非静态代码块
无参构造
这是非静态代码块
有参构造

3、实例初始化过程：创建对象时，为对象进行初始化的操作

（1）为成员变量显示赋值
（2）执行非静态代码块
（3）执行构造器
Java编译器会把这是那部分的代码，合成一个叫做(【形参列表】)实例初始化方法，即编译后的.class字节码信息中，是没有构造器这个概念的
(【形参列表】)实例初始化方法的代码就是由三个部分组成
（1）为成员变量显示赋值的代码
（2）非静态代码块中的代码
（3）构造器中的代码
1和2按顺序执行，3一定是最后执行的

public class TestBlock {
	public static void main(String[] args){
		//MyClass my = new MyClass();//调用无参构造
		//MyClass my2 = new MyClass("jkworld");//调用有参构造
		demo d1 = new demo();
		demo d2 = new demo("jk");
	}

}
class demo{
	{
		 System.out.println("这是非静态代码块1");
	 }
	private String str=assign();
	
	public demo(){
		 System.out.println("无参构造");
	 }
	 public demo(String str){
		 this.str=str;
		 System.out.println("有参构造");
	 }
	 {
		 System.out.println("这是非静态代码块2");
	 }

	public String assign(){
		System.out.println("assign方法");
		return "hello";
	}
}

结果为：
这是非静态代码块1
assign方法
这是非静态代码块2
无参构造
这是非静态代码块1
assign方法
这是非静态代码块2
有参构造

为对象进行初始化操作在这里插入图片描述
构造器练习01

public class TestInit {

	
	public static void main(String[] args) {
		/*Father f = new Father();
		 * 父类的无参构造
		 * 
		 * Son s = new Son();
		 * 父类的无参构造
         * 子类的无参构造
         * 
         * Son s2 = new Son("jk",12);
         * 
         * 先执行this(str)
         * 父类的无参构
         * 子类的有参构造1
         * 子类的有参构造2

		 */
         Son s2 = new Son("jk",12);
	}

}
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");
	}
	
	
}

练习02

/*
 * 先执行父类的实例初始化方法
 */

public class TestInnit2 {

	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(){
		System.out.println("4、这是子类的无参构造");
	}
}

结果为：
1、父类的非静态代码块
2、这是父类的无参构造
3、子类的非静态态代码块
4、这是子类的无参构造

练习03

public class TestInnit2 {

	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 strFu;
	}
}

class Zi extends Fu{
	private String strZi=assignZi();
	{
		System.out.println("4、子类的非静态态代码块");
	}
	public Zi(){
		System.out.println("5、这是子类的无参构造");
	}
	public String assignZi(){
		System.out.println("子类的assign方法");
		return strZi;
	}
}

结果为：
3、父类的assign方法
1、父类的非静态代码块
2、这是父类的无参构造
6、子类的assign方法
4、子类的非静态态代码块
5、这是子类的无参构造
（若子类和父类的方法名相同，则输出的都是子类的assign方法）
在init中隐含了str=this.assign(),在构造器中，在实例初始化方法中代表的是正在创建的对象，现在创建的是子类的对象，因为子类重写了assign方法，那么执行的是子类重写的assign方法

类的初始化

package demo;
/*
 * (1)类的初始化
 * <clinit>(){
 *   int x=5; //局部变量（声明了）
 *   x--;     //局部变量   x=4
 *   Test07.x--;//静态变量  默认是是0 ，x=-1
 * }
 * 
 * （2）执行main方法
 *     System.out.println("x="+x); //静态变量  x=-1
 *     z--; //静态变量   z=-1
 *     method();
 *     y=z++ + ++z; //静态变量  z++=-1 z=0,++z=1 z=1  y=-1+1=0
 *     System.out.println("result:"+(z+y+ ++z)); //静态变量  z=1,y=0,++z=2 z=2 ->result=3
 */

public class Test07{
	static int x,y,z; //类变量，静态变量，成员变量
	static{
		int x=5; //局部变量（声明了）
		x--;     //局部变量
	}
	static{
		x--; //这里是使用，是静态变量
	}
	public static void main(String[] args){  //方法是静态的，可以直接使用变量
		System.out.println("x="+x); //静态变量
		z--; //静态变量
		method();
		System.out.println("result:="+(z+y+ ++z)); //静态变量
		
	}
	public static void method(){
		y=z++ + ++z; //静态变量
	}
}

分析：
(1)类的初始化

(){
int x=5; //局部变量（声明了）
x–; //局部变量 x=4
Test07.x–;//静态变量默认是是0 ，x=-1
}
（2）执行main方法

System.out.println("x="+x); //静态变量  x=-1

```
z--; //静态变量   z=-1
```
```
method();
```

y=z++ + ++z; //静态变量  z++=-1 z=0,++z=1 z=1  y=-1+1=0

System.out.println("result:"+(z+y+ ++z)); //静态变量  z=1,y=0,++z=2 z=2 ->result=3

*/
结果为：
x=-1
result:=3

实例初始化
1、子类重写父类的方法

package demo;
/*
 * 实例初始化
 *1、 Base b1 = new Base(); //父类的实例初始化，与子类无关
 * <init>(){
 *    method(100);
 *    System.out.println("base:"+i);  base:100
 * }
 * 2、Base b2 = new Sub();
 * （1）父类的实例初始化
 * <init>(){
 *    method(100);  //执行的子类重写的method方法
 *    System.out.println("sub:"+j);  base:100
 * }
 * （1)子类的实例初始化
 * <init>(){
 *    method(70);  //执行的子类重写的method方法
 *    System.out.println("base:"+j);  base:70
 * }
 */

public class Test08 {
	public static void main(String[] args) {
		Base b1 = new Base();
		Base b2 = new Sub();

	}

}
class Base{
	Base(){
		method(100);
	}
	public void method(int i){
		System.out.println("base:"+i);
	}
}
class Sub extends Base{
	Sub(){
		super.method(70);
	}
	public void method(int j){
		System.out.println("sub:"+j);
	}
}

分析：
实例初始化
*1、 Base b1 = new Base(); //父类的实例初始化，与子类无关

(){
method(100);
System.out.println(“base:”+i); base:100
}
2、Base b2 = new Sub();
（1）父类的实例初始化
(){
method(100); //执行的子类重写的method方法
System.out.println(“sub:”+j); base:100
}
（1)子类的实例初始化
(){
method(70); //执行的子类重写的method方法
System.out.println(“base:”+j); base:70
}

结果为：
base:100
sub:100
base:70

若子类没有重写父类的方法，则结果为：
base:100
base:100
base:70

package demo;
/*
 * 实例初始化的过程：
 * （1）父类的实例初始化
 * <init>(){
 *    System.out.print("1");
 * }
 * （1）子类的实例初始化
 * <init>(String name){
 *    System.out.print("3");
 *    father = new People(name+"F"); //创建了一个父类的对象
 *        调用父类的<init>(String name){
 *            System.out.print("2");
 *        }
 *        
 * }
 */

public class Test09 {

	public static void main(String[] args) {
		new Child("mike");  //这里是子类先看子类
		
}
}
class People{
	private String name;
	
	public People() {
		System.out.print("1");
	}

	public People(String name) {
		System.out.print("2");
		this.name = name;
	}
}
class Child extends People{
	People father;

	public Child(String name) {
		//隐含了super()父类的无参构造
		System.out.print("3");
		father = new People(name+"F");
	}
	public Child() {
		System.out.print("4");
	}
	
}

结果为：132

package demo;

/*
 * new A(new B());
 * (1)new B()
 * <init>(){
 *    System.out.println("B");
 * }
 * 
 * (2)new A(B的对象)
 * <init>(B b){
 *    this(); //调用本类的
 *        System.out.println("A");
	  System.out.println("AB");
 * }
 */
public class Test10 {

	public static void main(String[] args) {
		new A(new B());
	}
}

class A {
	public A() {
		System.out.println("A");
	}

	public A(B b) {
		this();
		System.out.println("AB");
	}
}

class B {
	public B() {
		System.out.println("B");
	}
}

结果为：
B
A
AB

d-isease

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
面向对象---类(类/实例初始化）

1、类的成员：（1）属性：成员变量（2）方法：成员方法（3）构造器（4）代码块①非静态代码块②静态代码块：static2、非静态代码块（1）声明的格式【修饰符】 class 类名{ { 非静态代码块； }}(2)非静态代码块在声明时候执行？在创建对象的时候执行比构造器先早public class TestBlock { public static void main(String[] args){ MyClass my = new
复制链接

扫一扫

专栏目录