Java_day_10_封装、this、static、权限控制

package day_02._01_This;

/**
 * this 是什么 : 是每个对象中,保存自身内存地址的一个引用类型变量
 * 		this就表示当前对象
 * 
 * 能做什么
 * 		1 在成员方法或者构造方法中,区分同名的成员变量和局部变量
 * 					this.xxx
 * 		2 用在构造方法中,重载调用当前类中其他构造方法,但是必须写在构造方法第一行
 * 				this(xxx)
 * 		3 return this  返回当前对象的内存地址,可以链式调用
 * 
 * 谁调用的这个成员方法,this就是谁
 * 
 * 注意 this不能使用在静态方法中
 * 
 * @author SEC90
 * @Date 2022年1月10日 上午9:13:04
 */
public class This_01 {

	public static void main(String[] args) {
		MyDate date1 = new MyDate();
		date1.setYear(2022);
		date1.setMonth(1);
		date1.setDay(10);
		date1.print();
		
		// 创建对象的时候,年月日必须有值(构造方法赋值)
		MyDate date2 = new MyDate(2023, 2, 11);
		date2.print();
		
		// 需求 创建对象的时候,可以通过有参构造传入年月日,同时如果不传递年月日则默认为1970年1月1日
		MyDate date3 = new MyDate();
		date3.print();
	}

	// 静态变量
	static int b = 2;

	public static void m2() {
		int a = 2;
		int b = 2;
		// 静态变量可以和局部变量同名
		// 局部变量优先级更高
		// 可以使用类名区分同名的静态变量和局部变量
		System.out.println(a);
		System.out.println(This_01.b);
		System.out.println(b);
	}

	// 成员变量
	int d = 2;

	public void m1() {
		// 成员变量可以和局部变量同名
		// 局部变量优先级更高
		// 可以使用this区分同名的成员变量和局部变量
		int c = 2;
		System.out.println(c);
		System.out.println(d);
		int d = 3;
		System.out.println(d);
		System.out.println(this.d);
	}
}

class MyDate {
	private int year;
	private int month;
	private int day;

	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 MyDate() {
		// this.year = 1970;
		// this.month = 1;
		// this.day = 1;
		// 上面代码 也是可以实现的,但是偏离代码复用的本质,而且也影响代码美观和可读性
		// 调用当前类的指定构造方法
		// 但是 该写法 只能写在构造方法中,并且必须是在第一行
		this(1970, 1, 1);
	}

	public MyDate(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}

	public void print(){
		System.out.println(year+"年"+month+"月"+day+"日");
	}
}

package day_02._01_This;


public class This_02 {
	public static void main(String[] args) {
		This_02 t = new This_02();
		
		t.m1();
		t.m2();
		// 链式调用
		t.m1().m2();
	}

	public This_02 m1() {
		System.out.println("m1");
		return this;
	}

	public void m2() {
		System.out.println("m2");
	}
}

package day_02._02_Static;

/**
 * static 能做什么
 * 		1 在类体中使用static修饰的变量 是 静态变量
 * 		2 用static修饰的方法,是静态方法
 * 		3 还可以使用static定义静态语句块
 * 
 * @author SEC90
 * @Date 2022年1月10日 上午10:17:01
 */
public class Static_01 {
	public static void main(String[] args) {
		System.out.println("=========");
		System.out.println(i);
	}
	 
	// 静态变量
	static int i = 2;
	// 静态方法
	public static void m1(){
		
	}
	// 静态语句块,等同于静态方法
	// 静态语句块自动执行,在程序加载阶段执行完成,并且只执行一次
	// 由于执行时机是在main之前,并且只执行一次,所以非常适合做一些初始化工作
	// 访问一个类的静态属性的时候,类加载
	static{
		System.out.println("----------");
	}
	// 多个static语句块,从上往下执行
	static{
		System.out.println("-----222");
	}
}

package day_02._02_Static;

/**
 * 实例语句块 可以看做成员方法,没有static修饰的语句块就是成员语句块
 * 
 * 创建对象之后,立刻执行 , 每创建一个对象,就执行一次 并且在构造方法之前
 * 
 * @author SEC90
 * @Date 2022年1月10日 上午10:36:45
 */
public class Static_02 {
	{
		System.out.println("实例语句块1");
	}
	{
		System.out.println("实例语句块2");
	}
	static{
		System.out.println("静态语句块");
	}
	Static_02(){
		System.out.println("构造方法");
	}
	public static void main(String[] args) {
		System.out.println("main方法");
		new Static_02();
		new Static_02();
	}
}

package day_02._02_Static;

public class Test {
	static{
		System.out.println("=======");
	}
public static void main(String[] args) {
	System.out.println(Static_01.i);
}
}

package day_02._03_Package;

/**
 * package : 软件包机制
 * 		1 主要解决了命名冲突问题,在类名前加命名空间
 * 		2 完整的类名是带有包名的  , 包名.类名 才是这个类的名字
 * 		3 package语句 必须出现在java源文件的第一行
 * 		4 package语句是 规定编译之后的class文件保存的位置,和源文件无关
 * 		5 命名规则  一般采用公司域名倒叙
 * 				com.tledu.oa.system
 * 
 * @author SEC90
 * @Date 2022年1月10日 上午10:47:32
 */
public class Package_01 {
	public static void main(String[] args) {
		System.out.println(A.i);
	}
}

package day_02._03_Package;

// 导入时间类

import java.util.Date;
// .* 表示导入util下所有类
import java.util.*;

import day_02._03_Package.pojo.User;

/**
 * import 语句 用于把当前类中需要的其他类,载入
 * 
 * 必须出现在class语句之上,package语句之下
 * 
 * java.lang.* : 该包下所有类均为系统核心类,使用时不需要导入
 * 
 * 注意 : 按空格 或者回车的时候 会自动导包,如果程序没有问题,但是报错,可以查看一下是否导包错误
 * 
 * @author SEC90
 * @Date 2022年1月10日 上午11:08:57
 */
public class Package_02 {
	public static void main(String[] args) {
		// 因为A和当前类在同包下,所以直接写类名即可找到A
		System.out.println(A.i);
		// 只要不在同包下,必须通过 包名.类名 才能找到该类
		day_02._03_Package.pojo.User user = new day_02._03_Package.pojo.User();
		User user1 = new User();
		Date date = new Date();
		String string = "";
	}
}

package day_02._03_Package;


// 静态导入,把一个类中的静态属性导入,在当前类中可以直接写名字调用,可以省略类名
import static day_02._03_Package.pojo.User.*;
import day_02._03_Package.pojo.User;

public class Package_03 {
	public static void main(String[] args) {
		System.out.println(User.age);
		System.out.println(age);
		System.out.println(name);
	}
}

package day_02._04_PPP;

import day_02._04_PPP.com.B;

/**
 * public : 公共的 哪里都能访问
 * 
 * private : 只能在当前类访问
 * 
 * default : 不写权限控制修饰符,默认为default , 同包中 即可访问
 * 
 * protected : 受保护的,继承权限,要么同包,要么有继承关系
 * 
 * @author SEC90
 * @Date 2022年1月10日 下午2:07:59
 */
public class PPP_01 {
	public static void main(String[] args) {
		// 同包测试
		// 公共的 可以
		System.out.println(A.a);
		// 私有的 不行
		// System.out.println(A.b);
		// 默认的 可以
		System.out.println(A.c);
		// 受保护的 可以
		System.out.println(A.d);

		// 不同包测试
		// 公共的 可以
		System.out.println(B.a);
		// 私有的 不行
		// System.out.println(B.b);
		// 默认的 不行
		// System.out.println(B.c);
		// 受保护的 不行
		// System.out.println(B.d);
	}
}

package day_02._05_Extends;


/**
 * 继承 : 就是在已有的类中派生出新的类,新的类能吸收已有类的属性和行为
 * 
 * java中 只支持单继承,不支持多继承,并且继承可以传递
 * 
 * 一个类只能继承一个父类,但是一个类可以被很多子类继承
 * 
 * 继承目的 : 代码复用,提高效率,如果父类满足不了子类需求的话,还可以进行覆写,可以使用多态
 * 
 * 如果一个类没有显示继承一个类,那么该类 默认继承 Object 
 * 		java.lang.Object 是Java中提供的根类,所有类都会直接或者间接性的继承这个类
 * 
 * 
 * 语法 : class 类名 extends 父类名 {类体 }
 * 
 * @author SEC90
 * @Date 2022年1月10日 下午2:18:48
 */
public class Extends_01 {
	public static void main(String[] args) {
		SubClass sub = new SubClass();
		sub.m1();
		sub.m2();
	}
}

package day_02._05_Extends;

public class SubClass extends SupClass{
	public void m1(){
		System.out.println("我是子类m1");
	}
}

package day_02._05_Extends;

public class SupClass {
	protected void m2(){
		System.out.println("我是父类m2");
	}
}

package day_02._06_Super;

public class SubClass extends SupClass{
	SubClass(){
		super(1);
		System.out.println("子类构造");
	}
	int age = 19;
	public void m1(){
		System.out.println("子类m1");
	}
	public void m2(){
		// 子类
		m1();
		// 子类
		System.out.println(age);
		// 父类
		System.out.println(name);
		// 父类
		super.m1();
		// 父类
		System.out.println(super.age);
	}
}

package day_02._06_Super;

public class SupClass {
	SupClass(int i) {
		super();
		System.out.println("父类构造");
	}

	int age = 18;
	String name = "张三";

	public void m1() {
		System.out.println("父类m1");
	}
}

package day_02._06_Super;

/**
 * super : 官方说法是  代表了父类的特征
 * 
 * 1 用在成员方法和构造方法中 区分父子类之间同名的方法和变量
 * 			super.xxx
 * 2 用在子类构造方法中,调用指定的父类构造方法
 * 			super(xxx);
 * 		如果在子类构造方法中,没有显示出现super() 也没有出现 this(xxx)  则 默认有一个super() 调用父类无参构造
 * 		并且 super(xxx) 必须出现在子类构造方法 第一行  所以 this(xxx) 和 super(xxx) 不能同时出现
 * 
 * @author SEC90
 * @Date 2022年1月10日 下午2:41:08
 */
public class Super_01 {
	public static void main(String[] args) {
		 SubClass sub = new SubClass();
		 sub.m2();
	}
}

package day_02._07_Override;

/**
 * 覆写/重写 : 写一个和父类一样的方法,但是功能 不一样
 * 
 * 1 方法名,返回值,参数列表 必须和父类一致
 * 
 * 2 不能比原方法拥有更低的访问权限
 * 
 * 3 不能比原方法拥有更宽泛的异常
 * 
 * 当父类功能无法满足子类需求的时候,进行覆写
 * 
 * 覆写 特指成员方法, 也就是 只有成员方法 可以覆写 
 * 
 * @author package day_02._07_Override;

/**
 * 覆写/重写 : 写一个和父类一样的方法,但是功能 不一样
 * 
 * 1 方法名,返回值,参数列表 必须和父类一致
 * 
 * 2 不能比原方法拥有更低的访问权限
 * 
 * 3 不能比原方法拥有更宽泛的异常
 * 
 * 当父类功能无法满足子类需求的时候,进行覆写
 * 
 * 覆写 特指成员方法, 也就是 只有成员方法 可以覆写 
 * 
 * @author SEC90
 * @Date 2022年1月10日 下午3:31:40
 */
public class Override_01 {
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.eat();
	}
}

class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}

	public void move() {
		System.out.println("动物在移动");
	}
}

class Cat extends Animal {
	// @Override : 是源码注解,在编译的时候会判断该方法是否为覆写的方法,防止拼写错误等,如果写错了就会报错
	// 如果不加这个注解,也是没关系的,只不过 比如方法名写错了,此时不算覆写了,但是也不会报错
	// 所以 加上这个注解 可以降低错误率 , 并且 该注解在编译为class文件后,就会被去掉
	@Override
	public void eat() {
		// 此时 Animal中的eat方法,已经不能满足子类需求了,所以进行覆写
		System.out.println("猫吃鱼");
	}
}
 * @Date 2022年1月10日 下午3:31:40
 */
public class Override_01 {
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.eat();
	}
}

class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}

	public void move() {
		System.out.println("动物在移动");
	}
}

class Cat extends Animal {
	// @Override : 是源码注解,在编译的时候会判断该方法是否为覆写的方法,防止拼写错误等,如果写错了就会报错
	// 如果不加这个注解,也是没关系的,只不过 比如方法名写错了,此时不算覆写了,但是也不会报错
	// 所以 加上这个注解 可以降低错误率 , 并且 该注解在编译为class文件后,就会被去掉
	@Override
	public void eat() {
		// 此时 Animal中的eat方法,已经不能满足子类需求了,所以进行覆写
		System.out.println("猫吃鱼");
	}
}