Java_Day_10_面向对象_总结

成员变量：随对象的存在而存在，随对象的消失而消失。其值存储在对象实例中

静态变量：随类存在而存在，随类消失而消失。存储在静态区，经过方法访问改变静态变量值时，其值在静态区的值会改变。

局部变量：随方法而存在，方法在变量在。

变量使用就近原则，哪个近用哪个

this是什么:是每个对象中,保存自身内存地址的一个引用类型变量
 * 
 *       this就表示当前{对象}
 * 
 *       能做什么:
 * 
 *       1、在成员方法或者构造方法中，区分同名的成员变量和局部变量
 * 
 *       this.xxx
 * 
 *       2、用在构造方法中,重载调用当前类中其他构造方法但是必须写在构造方法第一行
 * 
 *       this.(xxx)
 * 
 *       3、return this 返回当前的对象的内存地址
 * 
 *       this最简单理解，谁调用就是指向谁的堆地址
 * 
 *       this 不能出现在静态方法中

public class This_01 {
	static int a = 2;
	int year;
	int month;
	int day;

	public This_01() {
		this(1999, 12, 24);// 这样调用必须在第一行
	}

	// 有参构造方法的使用
	public This_01(int year, int month, int day) {
		super();
		this.year = year;
		this.month = month;
		this.day = day;
		m();
	}

	public void m() {
		//接收赋值过后的参数
		System.out.println(year + "年" + month + "月" + 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;
	}

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

	public static void m2() {
		int a = 3;
		int b = 4;

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

	public static void main(String[] args) {
		This_01 Date = new This_01();
		This_01 Date1 = new This_01(2022, 1, 1);
		System.out.println(Date1);
		System.out.println(Date);

	}
}

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;//返回调用m1这个方法的对象的地址，简单来说就是，返回该  对象
	}

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

	}

         Static
 *       1.静态变量，静态方法修饰符所修饰的都是和类一起加载在静态区。main方法之前
 * 
 *       2.static修饰静态语句块，等价于静态方法
 *
 *       静态变量和静态语句块同等优先级

           实例语句块:
 *       可以看做成员方法,没有static修饰的语句块就是成员语句块
 * 
 *       等价于成员方法，在创建对象时立刻执行

 *       继承:就是在已有的类中派生出新的类，新的类能吸收已有的类的属性和行为
 * 
 *       java 中只支持单继承，不支持多继承，可以传递
 * 
 *       代码复用提高效率，如果父类满足不了子类，可以复写可以使用多态
 * 
 *       如果一个类没有显示继承，默认继承java.lang.Object
 * 
 *       语法结构：修饰符 子类 extend 父类{类体}

super:代表了父类的特征
 *       1.用在成员方法和构造方法中 区分父子类之间的同名的方法和变量
 * 
 *       super.xxx  使用父类时的前缀
 * 
 *       2.在子类的构造方法中，调用指定的父类的构造方法
 * 
 *       super();   
 * 
 *       super()和this（）都必须在第一行，所以不能重复出现

public void m2(){
		// 子类
		m1();
		// 子类
		System.out.println(age);
		// 父类
		System.out.println(name);
		// 父类
		super.m1();
		// 父类
		System.out.println(super.age);
	}

  package包机制：
 
 *       1.主要解决了命名冲突问题，在类名前加命名空间
 * 
 *       2.完整的类名是带有包名的,包名类名才是这个类的名字
 * 
 *       3.package语句必须出现在java源文件的第一行
 * 
 *       4.package语句是规定编译之后的class文件保存的位置，和源文件无关
 * 
 *       5.一把采用公司域名倒序
 * 
 *       6.不在同包下，要用包名.类名调用
 * 
 *       7.导包，import 导入其他包中的其他类。在package之下，class之上
 * 
 *       8.java.lang,*:该包下为系统核心类不需要导包。*表示该包下所有类

public class FengZhuang_04 {
	public static void main(String[] args) {
		Date date = new Date();// 回车自动添加包
		System.out.println(date);
		//调用user包中的类
		User_ us = new User_();
		us.m();
	}
}

 

 访问控制符      同一类中 同包中 同一子类中 其他
  
 *       private         是         否         否         否
 * 
 *       default         是         是         否         否   （不写权限控制修饰符）
 * 
 *       protected     是         是         是
 * 
 *       public           否         是         是         是
 

覆写：写一个和父类一样的方法，但是功能不一样 父类无法满足子类需求
 * 
 *       1.方法名 返回值 参数列表 和父类一致
 * ‘
 *       2.不能比原方法更低的访问权限
 * 
 *       3.不能比原方法有更多的异常
 *       
 *       只有成员方法可以覆写

public class FuXie_07 {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.eat();
		dog.move();
	}
}

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

	public void move() {
		System.out.println("自驾走");
	}
}

class Dog extends Animal {
	@Override
	// 源码注解，编译时判断是否为覆写方法，会报错，降低错误率
	public void eat() {
		System.out.println("狗吃鱼");
	}

}