day_10 this、static、封装

最新推荐文章于 2024-07-25 13:40:37 发布

吾既神明

最新推荐文章于 2024-07-25 13:40:37 发布

阅读量76

点赞数

文章标签： java eclipse

本文链接：https://blog.csdn.net/G_z_s/article/details/120723058

版权

1.面向对象

1.4实例化和使用

		/**
		 * 变量: 存储数据,方便操作
		 * 变量声明:数据类型 变量名 = 值;
		 * 数据类型:基本和引用 引用:接口,数组,类
		 * 所有引用类型,都可以赋值为null
		 * 整数:默认0 小数默认:0.0 布尔默认:false 字符默认:\u0000 引用:默认null
		 * 
		 * 实例化步骤:
		 * 1 把类加载到静态区
		 * 2 new会在堆内存中创建内存空间
		 * 3 调用构造方法,对该空间进行初始化操作,吧成员属性复制到该空间中
		 * 4 构造方法执行完弹栈,最后把堆内存对象的地址,赋值给变量 
		 */

package day_10text;
int age;
public class Text01 {

	public static void main(String[] args) {
		//创建了一个Text01类型的变量,并创建了一个Text01的对象,把该对象的内存地址赋值给a这个变量
		Text01 a =new Text01();
		//每new一次 都会创建一个全新的对象
		Text01 a1 =new Text01();
		//更改a1对象中age的值
		a1.age =2;
		//调用a中的成员变量age 是0
		System.out.println(a.age);
		//调用a1中的成员变量age 是2
		System.out.println(a1.age);
	}

}

1.5Javabeen

JavaBean : JavaBean是公共Java类，但是为了编辑工具识别，需要满足至少三个条件：有一个public默认构造器（例如无参构造器,）属性使用public 的get，set方法访问，也就是说设置成private，同时get，set方法与属性名的大小也需要对应。例如属性name，get方法就要写成，public String getName(){},N大写。需要序列化。这个是框架，工具跨平台反映状态必须的最近看<Think in Java>,里面讲到JavaBean最初是为Java GUI的可视化编程实现的.你拖动IDE构建工具创建一个GUI 组件（如多选框）,其实是工具给你创建java类,并提供将类的属性暴露出来给你修改调整,将事件监听器暴露出来.

EJB : 在企业开发中，需要可伸缩的性能和事务、安全机制，这样能保证企业系统平滑发展，而不是发展到一种规模重新更换一套软件系统。然后有提高了协议要求，就出现了Enterprise Bean。EJB在javabean基础上又提了一些要求，当然更复杂了。

POJO : 有个叫Josh MacKenzie人觉得，EJB太复杂了，完全没必要每次都用，所以发明了个POJO，POJO是普通的javabean，什么是普通，就是和EJB对应的。总之，区别就是，你先判断是否满足javabean的条件，然后如果再实现一些要求，满足EJB条件就是EJB，否则就是POJO。

/**
 * 1 所有属性为private
 * 2 提供默认构造方法
 * 3 提供getter和setter
 * @author 学到头秃的张张张
 *@Date 2021年10月12日下午6:31:09
 */

1.6常见异常

		c = null;
		// java.lang.NullPointerException 空指针异常
		// 当我们使用null值,去调用 成员 属性的时候,会报出空指针异常
		 System.out.println( c.getAge() );

1.7对象调用静态属性

		c=null;
		// 不会出现错误,因为 i 是静态属性,和堆内存无关
		// 当我们使用 引用类型变量调用 静态属性的时候,在编译时就会把该变量转换为对应的类名去调用
		System.out.println(c.i);
		
		Customer c1 = new Customer();
		// 不管是不是null,都会转换为类名调用
		// 所以又说 静态变量是所有对象共有的属性和值
		System.out.println(c1.i);
		System.out.println(Customer.i);

package day_10text;

public class Text02 {

	public static void main(String[] args) {
		//创建对象
		Customer c = new Customer();
		c.setAge(18);
		c.setName("张三");
		System.out.println(c.getName());
		System.out.println(c.getAge());
	}

}
class Customer {
	//权限控制符 private 私有成员变量
	private int age;
	private String name;
	//成员方法
	public void setAge(int age_) {
		age = age_;
	}
	
	public void setName(String name_) {
		name = name_;
	}

	public int getAge() {
		return age;
	}

	public String getName() {
		return name;
	}
}

1.8变量优先级

package day_10text;

public class Text04 {
	//静态变量和成员变量不可以同名
	int a=1;
	//再定义静态变量不能使用相同名字的a static int a = 1;
	static int b =1;
	public static void main(String[] args) {
		//一个作用域中 不可以有同名的变量
		int t =2;
		//int t =3;
		//局部变量可以和静态变量或者成员变量同名
		int a =5;
		int b =6;
		//当局部变量和静态变量重名时,在方法中,局部变量的优先级大于静态变量
		System.out.println(b);
		//想要使用静态变量,需要使用类名
		System.out.println(Text04.b);

	}

}

1.9区分同名的构造方法和成员方法

package day_10text;
/**
 * 成员方法和构造方法可以同名,需要使用返回值区分
 * 因为构造方法没有返回值,连void都没有
 *而成员方法有返回值,不需要返回数据也必须写void
 * @author 学到头秃的张张张
 *@Date 2021年10月12日下午7:39:05
 */
public class Text05 {

	public static void main(String[] args) {
		// Text05 o = new Text05(10);
		//这个语句是错误的 因为创建对象的时候如果不输入参数,系统会自动生成一个
		//无参构造方法,如果创建对象的时候在后面加了参数,那么就要提前构建有参构造方法
		Text05 o1 = new Text05();

	}
	//构造方法 方法是什么类型与输出语句无关
	public Text05() {
		System.out.println("我是构造方法");
	}
	//成员方法
	public void OOP_06(int i) {
		System.out.println("我是构造方法");
	}
}

2.this

2.1 this是什么

/**
 * this:是每个对象中保存自身内存地址的一个引用类型变量
 * this就表述这个对象自己,相当于我们说"我"一样
 * @author 学到头秃的张张张
 *@Date 2021年10月12日下午7:49:15
 */

2.1 this能做什么

/**
 *this作用
 *	1 用在成员方和构造方法中,可以区分同名的局部变量和成员变量
 *		语法:this .xxx =xxx;
 *	2 用在某个构造方法中 用于重载调用当前类中的其他构造方法,提高代码复用
 *		语法:this(参数);必须写在构造方法的第一行
 *	3 return this;可以用作链式调用
 *		核心原理:前者的返回值,一定是可以调用后者的引用
 *
 *在一个成员方法中,哪个对象调用的这个方法,this就是哪个对象
 * @author 学到头秃的张张张
 *@Date 2021年10月12日下午7:49:15
 */

2.3 this怎么用

2.3.1区分成员变量和局部变量

/**
 *	用在某个构造方法中 用于重载调用当前类中的其他构造方法,提高代码复用
 *		语法:this(参数);必须写在构造方法的第一行
 */

package day_10text;

public class Text06 {

	public static void main(String[] args) {
		Text06 t = new Text06(1);
		//调用成员方法 t就是this
		t.setAge(10);	
		//10
		System.out.println(t.age);
		
		Text06 t1 = new Text06(1);
		//调用成员方法 t1就是this
		t1.setAge(20);	
		//20
		System.out.println(t1.age);
	}

	int age;
    //有参构造
	public Text06(int age) {
		this.age = age;
	}
    
	public void setAge(int age) {
		//t.age = age;
		//谁调用的方法谁就是this    t   t1
		this.age = age;
	}
}

2.3.2构造方法重载调用(提高代码复用)

/**
 *	 用在某个构造方法中 用于重载调用当前类中的其他构造方法,提高代码复用
 *		语法:this(参数);必须写在构造方法的第一行
 */

package day_10text;

public class Text07 {

	public static void main(String[] args) {
		MyDate date1 = new MyDate();
		//1970年1月1日
		date1.print();
		
		date1.setYear(2021);
		date1.setMonth(10);
		date1.setDay(12);
		// 2021年10月12日
		date1.print();

		// 需求 : 创建时间对象的时候,必须有年月日(全参构造)
		MyDate date2 = new MyDate(2008, 8, 8);
		// 2008年8月8日
		date2.print();

		// 需求 : 创建时间对象的时候,可以传入年月日,也可以不传入年月日
		// 如果不传递,则默认是 1970年1月1日(一个全参,一个无参)
		MyDate date3 = new MyDate();
		// 1970年1月1日
		date3.print();
	}
}
class MyDate {
	// 成员变量
	private int year;
	private int month;
	private int day;

	// 全参构造
	public MyDate(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
		// xxxx
	}

	// 无参构造
	public MyDate() {
		// this.year = 1970;
		// this.month = 1;
		// this.day = 1;
		// 重载调用 上面的有参构造,做到代码复用
		// 但是 该语句 必须在构造方法第一行
		this(1970, 1, 1);
	}

	// getter/setter
	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public int getDay() {
		return day;
	}

	public void setDay(int day) {
		this.day = day;
	}

	// 需求 : 按照指定格式 打印 年月日
	public void print() {
		System.out.println(year + "年" + month + "月" + day + "日");
	}
}

2.3.3链式调用

/**
 *	 return this;可以用作链式调用
 *		核心原理:前者的返回值,一定是可以调用后者的引用
 */

package day_10text;

public class Text08 {
	public static void main(String[] args) {
		Text08 t = new Text08();
		t.m1();
		t.m2();
		// 链式调用
		// 前者的返回值,一定是可以调用后者的引用
		t.m1().m2().m2().m1();
	}
	//构造方法
	public Text08 m1() {
		System.out.println("我是m1方法");
		return this;
	}

	public Text08 m2() {
		System.out.println("我是m2方法");
		return this;
	}
}

2.3.4注意

this不能出现在静态上下文中(静态方法)

3.Static

3.1 Static是什么

static : 是个修饰符,用来区分静态和成员

3.2 Static能做什么

/**
 * static可以修饰三个东西;静态变量,静态方法,静态语句块
 * 		静态变量:类体中使用static修饰的变量
 * 		静态方法:使用static修饰的方法
 * 		静态语句块:使用static修饰的代码块(语句块)
 * 			一个大括号就是一个语句块
 */

3.3 Static怎么用

package day_10text;
/**	
 * 		语法:static{
 * 					代码块;
 * 				}
 * 
 * 在类加载阶段执行,加载完成就立刻执行,在main之前执行,并且只执行一次
 * 由于最先执行并且只执行一次,所以适合做一些准备初始化操作
 * @author 学到头秃的张张张
 *@Date 2021年10月12日下午8:38:46
 */
public class Text09 {

	public static void main(String[] args) {
		System.out.println("main方法");
	}
	// 多个语句块,从上往下执行
	static {
		System.out.println("静态语句块1");
	}
	static {
		System.out.println("静态语句块2");
	}
}

3.3.1静态变量初始化时机

package day_10text;

public class Text10 {
	public static void main(String[] args) {
		System.out.println("main");
	}

	// 静态变量 也是在类加载阶段初始化的,和静态语句块优先级一致,从上往下初始化
	static int i = 1;
	static {
		System.out.println("静态语句块 : " + i);
	}
	// static int i = 1;
}

3.3.2实例语句块

package day_10text;

/**
 * 实例语句块 : 可以看做没有名字的成员方法
 * 
 * 每次创建对象,都会执行一次,多个从上往下执行
 * 
 * 语法 : { 代码; }
 * @author 学到头秃的张张张
 *@Date 2021年10月12日下午8:49:45
 */
public class Text11 {
	public static void main(String[] args) {
		//优先级 2
		System.out.println("main方法");
		
		Text11 s = new Text11();
		Text11 s1 = new Text11();
	}
	public Text11(){
		System.out.println("构造方法");
	}
	//优先级 1
	static{
		System.out.println("静态语句块");
	}
	//优先级 3     每创建一次对象就执行一次
	{
		System.out.println("实例语句块");
	}
}

输出结果: