java对象的内存分配示意

最新推荐文章于 2024-04-22 20:14:53 发布

冰芷若涵

最新推荐文章于 2024-04-22 20:14:53 发布

阅读量110

点赞数

文章标签： java

本文链接：https://blog.csdn.net/baidu_41796276/article/details/113101488

版权

在这里插入图片描述

一,构造方法
–1,概述
–创建对象时会自动调用构造方法
–构造方法和其他方法一样也可以重载
–作用:完成对象的创建或者完成对象的初始化
–2,语法:
–普通方法:修饰词返回值方法名(参数列表){方法体}
–构造方法:修饰符类名(参数列表){方法体}
–3,构造方法完成创建对象
package cn.tedu.oop;
//测试构造方法Constructor / 构造器
//总结
//1,触发的时间节点:构造方法摆在那儿不会主动执行,需要new来触发
//2,构造方法可以重载,为了方便各种new,体现程序的灵活性
//3,构造方法在创建对象时,会自动执行
public class Test1_Constructor {
public static void main(String[] args) {
//创建对象测试
new Student(“1”,2);//触发了public Student(String a,int b)
new Student();//触发无参构造
new Student(“1”);//触发了public Student(String name)
new Student(1);//触发了public Student(int a)
new Student(1,2);//触发了public Student(int a,int b)
}
}
//创建Student类
class Student{
public Student(String a,int b) {
System.out.println(“含参构造,名字是:”+a+",年龄是:"+b);
}
//1,提供构造方法:修饰符类名(参数列表){方法体}
//5,默认就会存在无参构造–前提是.不能只提供含参的构造方法
public Student() { }
//3,重载-- 在同一个类里,方法名相同,但是参数列表不同
public Student(String name) {
System.out.println(“含参构造方法”+name);
}
public Student(int a) {
System.out.println(“含参构造方法”+a);
}
public Student(int a,int b) {
System.out.println(“含参构造方法”+a+b);
}
}

--4,构造方法完成对象的初始化
	package cn.tedu.oop;
	//测试 构造方法 初始化对象信息
	public class Test2_Constructor2 {
		public static void main(String[] args) {
			//1,需求:在创建对象时,给成员变量初始化
			Student2 s = new Student2("钟南山",85);
			//6,获取 私有属性 的值
			System.out.println(  s.getName()  );//钟南山
			System.out.println(  s.getAge()   );//85
		}
	}
	class Student2{
		//2, 给成员变量初始化--setXxx()--直接构造方法赋值
		private String name;
		private int age;
		//5,只对外提供获取方式
		public String getName() {
			return name;
		}
		public int getAge() {
			return age;
		}
		//3,默认就存在的 无参构造
		public Student2() {}
		//4,提供含参构造,并完成成员变量的初始化
		public Student2(String a,int b) {
			name = a;
			age = b;
			
		}
	}

二,代码块
–1,概述
–被花括号包起来的一段代码就叫代码块
–代码块的位置不同,作用用法名字都不同
–2,构造代码块
–成员位置(类里方法外)的代码块叫构造代码块
–作用:通常用于抽取构造方法中的共性代码
–顺序:new时,先调用构造代码块,然后调用构造方法,优先于构造方法加载
–3,局部代码块
–局部位置(方法里)的代码块叫局部代码块
–作用:通常用于控制变量的作用范围
–4,测试:
package cn.tedu.oop;
//测试代码块
//总结
//1,创建对象时:本来是只会触发构造方法,但是,如果有构造代码块,就会先触发构造代码块再执行构造方法
//2,调用方法时:顺序执行方法里的代码,如果有局部代码块也就一起执行
//3,执行顺序:new时–构造代码块>构造方法,调用方法时–局部代码块
//4,构造代码块–用来提取构造方法的共性–new时才触发
//5,局部代码块–用来控制变量的作用范围–调用方法时才触发
public class Test3_Block {
public static void main(String[] args) {
new Person().show();//触发无参构造
new Person(“熊大”);//触发含参构造
}
}
//创建Person类
class Person{
//1,构造代码块:位置是在成员位置–触发节点是 new时–先执行构造代码块再执行构造方法
//–作用:抽取构造方法的共性
int age ;
{
age = 0 ;//提取了所有构造方法的共性功能
System.out.println(“构造代码块”);
}
public Person() {
System.out.println(“无参构造方法”+age);
}
public Person(String name) {
System.out.println(“含参构造方法”+name+age);
}
//2,局部代码块:位置是在方法里–触发节点是当方法被调用时–用来控制变量的作用范围
public void show() {
{
int x = 10;
System.out.println(x);
System.out.println(“局部代码块”);
}
}
}

三,this关键字
–1,代表本类对象的一个引用对象
–2,作用:
–用来区分同名的成员变量和局部变量
–用来完成构造方法间互相调用
–3,测试1
package cn.tedu.oop;
//测试 this关键字
//总结
//当局部变量名和成员变量名相同时,需要用this调用成员变量
public class Test4_This {
public static void main(String[] args) {
//通过对象,来访问类里的成员(成员变量和成员方法)
new Demo().test();
// Demo d = new Demo() ;
// System.out.println( d.name );
System.out.println( new Demo().name );
}
}
//创建Demo类
class Demo{
String name ;
int count = 20 ;//成员变量

		public void test() {
			int count = 10;//局部变量
			System.out.println(count);//变量的就近原则,会使用局部变量 的值 10
			System.out.println(name);//成员变量
			//1,想要使用  和  局部变量 同名的 成员变量count--this调用成员变量
	//this表示的是本类的对象的引用--底层帮你new了一个本类对象--Demo this = new Demo();
			System.out.println( this.count );//20,成员变量
		}
	}
--4,测试2
	package cn.tedu.oop;
	//测试   this--用来完成 构造方法间 互相调用
	//总结
	//1,如果在构造方法间,互相调用时,this不能省略
	//2,位置必须是第一条语句
	public class Test5_This2 {
		public static void main(String[] args) {
	//		new Demo2();
			new Demo2(1);
		}
	}
	class Demo2{
		 public Demo2() {
			 //1,在 无参构造里  调用 含参构造
	//		 this(10);
			 System.out.println("无参构造");
		 }
		 public Demo2(int a) {
			 //2,在 含参构造里  调用 无参构造
			 this();//3,在构造方法中,使用this关键字,必须是第一条语句
			 System.out.println("含参构造"+a);
		 }
	}

四,继承
–1,概述
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。
–2,好处
提高父类代码的复用性,减少子类代码的编写,提高开发效率
–3,特点
–使用extends关键字
–相当于子类把父类的功能复制了一份
–java只支持单继承
–继承可以传递（爷爷，儿子，孙子的关系）
–不能继承父类的私有成员
–继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
–像是is a 的关系
–4,入门案例
package cn.tedu.oop;
//测试继承
public class Test6_Extends {
public static void main(String[] args) {
//创建Dog对象测试
new Dog().eat();
new Dog().sleep();
System.out.println( new Dog().name );
}
}
class God{
String name ;
}
//1,父类来了–提取子类的共性–提高了代码的复用性
class Animal extends God{
//5,父类的私有成员(成员变量/成员方法)不能被继承
private double sifangmoney = 100 ;

		public void eat() {
			System.out.println("啥都吃");
		}
	}
	//2,子类想拥有父类的功能--需要发生继承关系
	class Dog extends Animal{//4,java只支持单继承
		//3,相当于子类把父类的功能复制了一份
		//6,除了能用父类继承来的,还可以自己做扩展
		public void sleep() {
			System.out.println("sleep()..");
		}
	}
	class Cat{
	}

--5,super关键字
	--1,在子类中用,用来访问父类的成员(成员变量/成员方法)
	--2,super表示父类对象的引用,底层自动创建了一个父类的对象
	--3,如果在构造方法里使用super关键字,位置上必须是第一条语句
--6,方法的重写override
	--1,重写的前提是:发生继承关系+子类的方法声明和父类一样
	--2,啥时候需要重写?--想要改,改掉父类原来的实现时

一,继承的使用
–1,成员变量
package cn.tedu.oop;
// 测试继承成员变量的使用
//总结 : 在子类中,想用父类的成员变量
//1,子类和父类的变量名不相同时,可以省略super.
//2,子类和父类的变量名相同,必须用super来调用父类的资源,不能省略
public class Test1_Extends {
public static void main(String[] args) {
new Zi().show();
}
}
class Fu{
int count = 10;
int sum = 30 ;
}
class Zi extends Fu{
int num ;
int sum = 20 ;

		public void show() {
			int sum = 10 ;
			System.out.println(sum);//10,就近原则
			System.out.println(num);//0,使用了默认值
			System.out.println(this.sum);//this能够调用本类的成员变量
			
			//1,super代表父类对象的引用.可以在子类中,使用父类的内容
			//2,相当于super帮你创建了一个父类对象,Fu super = new Fu();
			System.out.println(super.count);//10,用了父类的 不同名的变量,可以省略super.
			System.out.println(super.sum);//30,用了父类的,和子类同名了
		}
		
	}



--2,成员方法
	package cn.tedu.oop;
	//测试 继承成员方法 的使用
	//1,子类 可以继承父类的方法们 -- 可以直接使用  
	//2,子类 可以进行扩展  -- 可以直接使用
	//3,子类 可以修改继承来的方法 -- 方法的重写override
	//4,什么时候需要重写?--想要改时!!!
	public class Test2_Extends2 {
		public static void main(String[] args) {
			//4,创建子类对象测试
			Zi2 zi = new Zi2();
			zi.eat();//重写前,使用了父类的,重写后,使用子类的
			zi.study();//重写前,使用了父类的,重写后,使用子类的
			zi.sleep();//子类特有的
		}
	}
	class Fu2{
		public void eat() {
			System.out.println("爸爸在吃猪肉");
		}
		public void study() {
			System.out.println("爸爸在学搓麻");
		}
	}
	class Zi2 extends Fu2{
		//2,子类可以把父类的所有方法都继承来使用,也可以修改(方法重写)
		//要求:继承+子类的方法声明和父类必须一样
		public void eat() {
			//3,调用父类原来的eat()--重写并不会影响父类的原有功能
	//		super.eat();
			System.out.println("儿子在吃菜");
		}
		public void study() {
			System.out.println("儿子在学java");
		}
		//1,子类 可以继承父类的方法们   还可以扩展自己的功能
		public void sleep() {
			System.out.println("sleep()...");
		}
		
	}

--3,构造方法
	package cn.tedu.oop;
	//测试 继承构造方法 的使用
	//总结
	//1,子类的构造方法里,默认就会存在super()--去调用父类的 无参构造
	//2,当创建子类对象时, 先执行  父类的构造方法 , 再执行 子类的构造方法
	public class Test3_Extends3 {
		public static void main(String[] args) {
			//3,创建子类对象测试
			new Zi3();//会先去执行父类的无参构造,再执行自己的
		}
	}
	class Fu3{
		//4,如果父类没提供无参构造(也就是只提供了含参构造)
	//	public Fu3() {
	//		System.out.println("父类的 无参构造");
	//	}
		public Fu3(int a) {
			System.out.println("父类的 含参构造"+a);
		}
	}
	class Zi3 extends Fu3{
		public Zi3() {
			//1,在子类的构造方法中,会隐藏着一行代码super()
	//		super();//2,会自动执行父类的无参构造--如果父类不提供无参构造会报错
			//5,调用 父类的 含参构造?
			super(10);//6,当super关键字,出现在构造方法里时,位置必须是第一条语句
			System.out.println("子类的 无参构造");
		}
		
	}

二,static关键字
–1,特点
–可以修饰成员变量，成员方法
–可以直接被类名调用
–随着类的加载而加载，优先于对象加载
–只加载一次，就会一直存在，不再开辟新空间
–全局唯一，全局共享
–static不能和this或者super共用，因为有static时可能还没有对象
–静态只能调用静态，非静态可以随意调用
–2,测试
package cn.tedu.oop;
//测试静态关键字
//总结:
//1,静态的调用关系—静态只能调用静态–非静态调用啥资源都可以
//2,静态资源是加载非常早的,随着类的加载就已经加载进内存了,比对象早
//3,静态资源的访问方式:通过对象调用 + 通过类名调用
public class Test4_Static {
public static void main(String[] args) {
//2,静态资源优先于对象加载,因为是随着类的加载就已经加载了
Student.coding();
System.out.println(Student.name);

			Student s = new Student();
			s.study();
			System.out.println(s.age);
			
	//1,静态资源,多了一种访问方式,除了可以用对象访问,更提倡用类名直接调用
	//		s.coding();
	//		System.out.println(s.name);
			Student.coding();
			System.out.println(Student.name);
			
			//3,静态资源是共享资源,能够被多个对象共享
			Student s1 = new Student();
			s1.name="陈子枢";
			
			Student s2 = new Student();
			System.out.println(s2.name);//陈子枢
		}
	}
	class Student{
		//普通资源 
		int age = 10;
		public void study() {
			//6,非静态调用关系? -- 调用任意资源
			System.out.println(age);
			System.out.println(name);
			coding();
			System.out.println("正在学习java");
		}
		//静态资源
		static String name ;
		static public void coding()  {
			//4,静态资源里,不能使用this或者super关键字!
	//		this.study();
	//		super.
			//5,静态调用关系? -- 只能调用静态,不能调用非静态的
			System.out.println(name);
	//		study();
			System.out.println("正在敲代码");
		}
	}

三,static代码块
–1,一段被花括号包起来的代码,而且被static修饰
static{…}
–2,位置是在成员位置,也拥有static关键字的特点
–3,测试
package cn.tedu.oop;
//测试代码块
//1,静态代码块:用来初始化项目–位置在成员位置
//2,执行顺序:
//类加载时 : 静态代码块
//实例化时 : 构造代码块 > 构造方法
//方法调用时 : 局部代码块
public class Test5_Block {
public static void main(String[] args) {
StaticDemo s = new StaticDemo();//先执行构造代码块然后执行构造方法
s.show();//执行局部代码块

			StaticDemo s2 = new StaticDemo();
		}
	}
	class StaticDemo{
		//静态代码块--位置也是在成员位置--用来完成项目的初始化
		//--只加载一次，在类第一次被加载时就跟着一起加载了(类的资源)
		static{
			System.out.println("静态代码块");
		}
		
		//构造代码块--位置是在成员位置--用来提取构造方法的共性
		{
			System.out.println("构造代码块");
		}
		//构造方法
		public StaticDemo() {
			System.out.println("构造方法");
		}
		//局部代码块--位置是在方法里--用来控制变量的作用范围
		public void show() {
			{	
				System.out.println("局部代码块");
			}
		}
	}

四,final关键字
–1,让子类的重写权限变得可控.如果父类的某个方法不让子类重写,可以用final修饰变成最终方法
–2,表示最终的意思.可以修饰类,成员变量,成员方法
–3,测试
package cn.tedu.oop;
//测试 final关键字
//1,final 修饰的类是最终的类,不能被继承
//2,final 修饰的变量,是一个最终的变量,值不能被修改,称之为是常量
//3,final 修饰的方法,不能被重写
public class Test6_Final {
public static void main(String[] args) {
//创建子类对象测试
Son s = new Son();
s.eat();
// s.sum = 20 ;//final前可以改也能使用
System.out.println(s.SUM);
}
}
//1,final修饰的类是最终的类,不能被继承–The type Son cannot subclass the final class Father
//final class Father{
class Father {
//3,final 修饰的变量,final用来修饰常量–The final field Father.sum cannot be assigned
// final int sum = 10 ;
static final int SUM = 10 ;
//2,final 修饰的方法,只能用不能被重写–Cannot override the final method from Father
final public void eat() {
System.out.println(“Father…eat()”);
}
}
class Son extends Father{
// //想要改,发生了重写!!
// public void eat() {
// System.out.println(“Son…eat()”);
// }
}

五,多态
–1,就是指同一个对象,在不同时刻,代表的对象不同.就是指同一个对象的多种形态.
–2,多态的作用 – 用来统一调用标准!!! 一切向父类看齐
–3,好处是 : 做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把子类当做父类来看.
–4,特点
–前提: 继承关系 + 方法的重写
–5,测试
package cn.tedu.oop;
//测试多态
public class Test7_Multi {
public static void main(String[] args) {
//创建子类对象测试
new Dog().eat();//重写前执行父类的,重写后执行子类的
//创建多态对象测试
Animal a = new Dog();//口诀1:父类引用指向子类对象
//口诀2:编译看左边,运行看右边
//编译看左边–是指想要保存成功,向左边也就是向父类看齐–统一标准!!
//运行看右边–是指结果向右边看齐也就是看子类的干活结果
a.eat();//狗吃肉
// a.test();//test()是子类的特有方法,多态对象只能调用父类的
}
}
class Animal{
public void eat() {
System.out.println(“啥都吃”);
}
}
//1,多态的前提:继承 + 方法重写(方法声明和父类一样)
class Dog extends Animal{
public void eat() {
System.out.println(“狗吃肉”);
}
public void test() {
System.out.println(“test…”);
}
}

六,多态的使用
–1,成员变量
–2,成员方法
–3,静态成员
–4,测试
package cn.tedu.oop;
//测试多态的使用
//总结
//1,多态中,的成员变量 – 用父类的
//2,多态中,的成员方法 – 用父类的方法声明,用子类的方法体
//TODO 3,多态中 ,的静态资源?
public class Test8_UseMulti {
public static void main(String[] args) {
//创建多态对象–父类引用指向子类对象
Fu4 fu = new Zi4();
//编译看左边,运行看右边
System.out.println( fu.name );//成员变量用谁的?–父类的
//多态中,方法声明用–父类的 ,方法体用–子类的(因为重写了)
fu.show();//成员方法用谁的?–子类的(重写了)
fu.test();//成员方法用谁的?–父类的(没重写)
}
}
class Fu4{
String name = “尼古拉斯.赵四” ;
public void show() {
System.out.println(“Fu4…show()”);
}
final public void test() {//被final了,不让子类重写了!
System.out.println(“Fu4…test()”);
}
}
class Zi4 extends Fu4{
String name = “Anglelababa”;
public void show() {
System.out.println(“Zi4…show()”);
}
}

java文件的运行过程
一,继承的使用
–1,成员变量
package cn.tedu.oop;
// 测试继承成员变量的使用
//总结 : 在子类中,想用父类的成员变量
//1,子类和父类的变量名不相同时,可以省略super.
//2,子类和父类的变量名相同,必须用super来调用父类的资源,不能省略
public class Test1_Extends {
public static void main(String[] args) {
new Zi().show();
}
}
class Fu{
int count = 10;
int sum = 30 ;
}
class Zi extends Fu{
int num ;
int sum = 20 ;
```
 	public void show() {
 		int sum = 10 ;
 		System.out.println(sum);//10,就近原则
 		System.out.println(num);//0,使用了默认值
 		System.out.println(this.sum);//this能够调用本类的成员变量
 		
 		//1,super代表父类对象的引用.可以在子类中,使用父类的内容
 		//2,相当于super帮你创建了一个父类对象,Fu super = new Fu();
 		System.out.println(super.count);//10,用了父类的 不同名的变量,可以省略super.
 		System.out.println(super.sum);//30,用了父类的,和子类同名了
 	}
 	
 }
```
–2,成员方法
package cn.tedu.oop;
//测试继承成员方法的使用
//1,子类可以继承父类的方法们 – 可以直接使用
//2,子类可以进行扩展 – 可以直接使用
//3,子类可以修改继承来的方法 – 方法的重写override
//4,什么时候需要重写?–想要改时!!!
public class Test2_Extends2 {
public static void main(String[] args) {
//4,创建子类对象测试
Zi2 zi = new Zi2();
zi.eat();//重写前,使用了父类的,重写后,使用子类的
zi.study();//重写前,使用了父类的,重写后,使用子类的
zi.sleep();//子类特有的
}
}
class Fu2{
public void eat() {
System.out.println(“爸爸在吃猪肉”);
}
public void study() {
System.out.println(“爸爸在学搓麻”);
}
}
class Zi2 extends Fu2{
//2,子类可以把父类的所有方法都继承来使用,也可以修改(方法重写)
//要求:继承+子类的方法声明和父类必须一样
public void eat() {
//3,调用父类原来的eat()–重写并不会影响父类的原有功能
// super.eat();
System.out.println(“儿子在吃菜”);
}
public void study() {
System.out.println(“儿子在学java”);
}
//1,子类可以继承父类的方法们还可以扩展自己的功能
public void sleep() {
System.out.println(“sleep()…”);
}
```
 }
```
–3,构造方法
package cn.tedu.oop;
//测试继承构造方法的使用
//总结
//1,子类的构造方法里,默认就会存在super()–去调用父类的无参构造
//2,当创建子类对象时, 先执行父类的构造方法 , 再执行子类的构造方法
public class Test3_Extends3 {
public static void main(String[] args) {
//3,创建子类对象测试
new Zi3();//会先去执行父类的无参构造,再执行自己的
}
}
class Fu3{
//4,如果父类没提供无参构造(也就是只提供了含参构造)
// public Fu3() {
// System.out.println(“父类的无参构造”);
// }
public Fu3(int a) {
System.out.println(“父类的含参构造”+a);
}
}
class Zi3 extends Fu3{
public Zi3() {
//1,在子类的构造方法中,会隐藏着一行代码super()
// super();//2,会自动执行父类的无参构造–如果父类不提供无参构造会报错
//5,调用父类的含参构造?
super(10);//6,当super关键字,出现在构造方法里时,位置必须是第一条语句
System.out.println(“子类的无参构造”);
}
```
 }
```

			Student s = new Student();
			s.study();
			System.out.println(s.age);
			
	//1,静态资源,多了一种访问方式,除了可以用对象访问,更提倡用类名直接调用
	//		s.coding();
	//		System.out.println(s.name);
			Student.coding();
			System.out.println(Student.name);
			
			//3,静态资源是共享资源,能够被多个对象共享
			Student s1 = new Student();
			s1.name="陈子枢";
			
			Student s2 = new Student();
			System.out.println(s2.name);//陈子枢
		}
	}
	class Student{
		//普通资源 
		int age = 10;
		public void study() {
			//6,非静态调用关系? -- 调用任意资源
			System.out.println(age);
			System.out.println(name);
			coding();
			System.out.println("正在学习java");
		}
		//静态资源
		static String name ;
		static public void coding()  {
			//4,静态资源里,不能使用this或者super关键字!
	//		this.study();
	//		super.
			//5,静态调用关系? -- 只能调用静态,不能调用非静态的
			System.out.println(name);
	//		study();
			System.out.println("正在敲代码");
		}
	}

			StaticDemo s2 = new StaticDemo();
		}
	}
	class StaticDemo{
		//静态代码块--位置也是在成员位置--用来完成项目的初始化
		//--只加载一次，在类第一次被加载时就跟着一起加载了(类的资源)
		static{
			System.out.println("静态代码块");
		}
		
		//构造代码块--位置是在成员位置--用来提取构造方法的共性
		{
			System.out.println("构造代码块");
		}
		//构造方法
		public StaticDemo() {
			System.out.println("构造方法");
		}
		//局部代码块--位置是在方法里--用来控制变量的作用范围
		public void show() {
			{	
				System.out.println("局部代码块");
			}
		}
	}