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