day7-5学习 this、static、封装、继承

面向对象

this

是什么

 是每个对象中，保存自身内存地址的一个引用类型变量

this就 相当于我们说自己一样

他能做什么

1 在成员方法中/构造方法中，区分同名的局部变量

  语法:this=***;

2在某个构造方法中，用于重载用当前类中其他的构造方法，提高代码的重用性

 语法: this(参数);必须在第一行

就像上面的这样

3  return this; 返回当前对象的内存地址，可以做到链式调用

怎么用

区分成员和局部变量

public void setYear(){
		this.year=year;
	}
	//全参构造
	public mydate(int year,int month,int day){
		this.year=year;
		this.month=month;
		this.day=day;
	}

重载调用构造方法

	// 无参构造
	public MyDate() {
		// this.year = 1970;
		// this.month = 1;
		// this.day = 1;
		// 上面代码,和有参构造代码是一样的,属于重复代码,如果有100行代码呢?就需要多写100行代码,
		// 尽管可以复制,但是也影响程序美观
		// 重载调用有参构造,必须在构造方法中的第一行(注释和换行之类的不算,有效代码的第一行)
		this(1970, 1, 1);
	}

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

链式调用

public class This_02 {

	public static void main(String[] args) {
		This_02 t = new This_02();
		t.m1().m2();
	}
	public This_02 m1(){
		System.out.println("我是m1");
		m2();
		return this;
	}
	public void m2(){
		System.out.println("我是m2");
	}
	public void removeOne(int data){
		removeMany(new int[]{data});
	}
	public void removeMany(int[] data){
		// xxxxx
	}
}

注意事项

1     重载调用构造方法语句,必须在构造方法第一行

// 无参构造
	public MyDate() {
		// this.year = 1970;
		// this.month = 1;
		// this.day = 1;
		// 上面代码,和有参构造代码是一样的,属于重复代码,如果有多行代码呢?就需要写多行代码,
		// 尽管可以复制,还是太麻烦
		// 重载调用有参构造,必须在构造方法中的第一行(注释和换行之类的不算,有效代码的第一行)
		this(1970, 1, 1);
	}

2 this不能出现在静态方法中

static

是什么

static 是一个修饰符，主要用来区分静态和动态属性

能做什么

1 static 修饰的类体中的变量是静态变量

        static int a=10;

2 static 修饰的方法是静态方法

     public static void main m1(){}

3 static 还可以定义静态语句块

           static{}

怎么用

静态变量和静态方法和静态语句块

public class Static_01 {
	// 静态语句块
	static{
		System.out.println("静态语句块1");
	}
	static{
		System.out.println("静态语句块2");
	}
	// 静态变量
	static int i = 20;
	// 静态方法
	public static void m1() {
		System.out.println("静态方法");
	}

}

调用其他类的静态属性会加载到相应的类到静态区

public class Static_02 {
	public static void main(String[] args) {
		// 调用其他类的静态属性,会加载对应的类到静态区
		System.out.println(Static_01.i);
	}
}

实例语句块

实例语句块 :等同看作成员方法

语法:{}

创建一次对象。就执行一次

public class Static_03 {
	// 实例语句块
	{
		System.out.println("实例1");
	}
	{
		System.out.println("实例2");
	}
	public static void main(String[] args) {
		System.out.println("main---");
		new Static_03();
		new Static_03();
	}
}

封装

是什么

封装是把对象的所有组成部分组合在一起，封装使用访问控制修饰符类的数据隐藏起来，控制用户对数据的访问和修改的程度，适当的封装可以让代码更容易理解和维护，也加强了代码的安全性

软件包机制

package

package : 是设置编译之后的class文件的保存位置，和源文件位置无关，如果源文件中，没有出现package语句，则class文件和源文件在同目录

软件包机制

1   为了解决命名冲突问题，在类名前加入命名空间

2  package 语句只能出现在java源文件的第一行，也可以没有

3  package 一般采用公司域名倒叙的方式

              com.tiedu.oa.system

     公司域名倒叙.项目名.模块名

4   带有package 语句的Java文件的编译

          javac -d生成路径 -encoding字符编码Java文件

          javac -d ./-encoding utf-8 xxx.java

          -d: disk 磁盘 ./表示当前目录

5    带有package语句的class文件的运行

             Java包名.类名

             Java.com.tledu.zrz.A

完整的类名是带有包名的，

能够找到这个文件的全路径，才是这个文件的文件名

public static void main(String[] args) {
		// 被调用的类和当前类如果在同一目录下(同包) 则可以直接使用
		// 否则就要写类全名
		_05_Package.com.tledu.User user = new _05_Package.com.tledu.User();
		user.m1();
	}

import

1    引入当前类中需要的其他类，否则就需要这些类名引入之后，可以直接写类名使用即可

2    必须出现在package 语句之下，class语句之上

3    import 包名.类名;只引入对应的某一个类

4    import 包名.*; 引入该包下所有的类

5    java.lang.* 下面的类是核心类，使用不需要导包

package _05_Package;
import java.util.Arrays;

import java.util.Date;

/**
 * import 
 * 		1 引入当前类中需要的其他类,否则就需要些类全名,引入之后,可以直接写类名使用即可
 * 		2 必须出现在package语句之下,class语句之上
 * 		3 import 包名.类名; 只引入对应的某一个类
 * 		4 import 包名.*; 引入该包下所有的类
 * 		5 java.lang.* 下面的类 是核心类,使用不需要导包
 * 
 */
import _05_Package.com.tledu.User;

public class Package_02 {
	public static void main(String[] args) {
		String  s = "";
		User user = new User();
		user.m1();
		Arrays.sort(new int[]{});
		// 导包的时候 注意别导错包,按下空格 和 回车的时候 也会自动导入
		// 比如Date  ,util下和sql下都有,就很容易出现错误,需要额外留意
		Date d = new Date();
	}
}

package _05_Package;

// 静态导入,当我们在使用其他类的静态属性的时候,就不需要使用类名调用了,而是直接写名字调用
// import static 包名.类名.属性;  导入某个静态属性
// import static 包名.类名.*;  导入所有静态属性
import static _05_Package.A.age;
public class Package_03 {
	public static void main(String[] args) {
		// 正常访问静态属性的时候,需要加类名
		System.out.println(A.age);
		// 这样的话,看不出来访问的是谁的变量,不建议这样使用
		System.out.println(age);
	}
}

class A {
	static int age = 19;
}

权限控制

 权限控制修饰符

       限制某个数据，可以被谁使用

       public，private，protected

     public: 公共的，谁都可以访问

     private : 私有的，只有当前类可以使用

     protected : 受保护的继承权限

        1   在有继承关系的体系中，通过子类调用

        2   同包，就算没有继承关系也可以访问

默认  : 当不使用以上三种修饰符进行修饰的时候，则是默认权限，只能让当前包中的类使用

package _06_PPP;

// 同包
public class A {
	// 默认
	static int a1 = 1;
	// 公共
	public static int a2 = 1;
	// 私有
	private static int a3 = 1;
	// 继承
	protected static int a4 = 1;
}

package _06_PPP;

import _06_PPP.com.B;

/**
 * 权限控制修饰符 
 * 		限制某个数据 可以 被谁使用
 * 		public , private , protected
 * 		public : 公共的,谁都能访问
 * 		private : 私有的,只有当前类可以访问
 * 		protected : 受保护的,继承权限,
 * 				1 在有继承关系的体系中,通过子类调用
 * 				2 同包,就算没有继承关系 也可以访问
 * 		默认 : 当不使用以上三种修饰符进行修饰的时候,则是默认权限,只能让当前包中的类使用
 * 
 * @author 啊超
 * @Date 2021年7月5日 
 */
public class PPP_01 {
	public static void main(String[] args) {
		// 默认
		System.out.println(A.a1);
		// 公共
		System.out.println(A.a2);
		// 私有
		// System.out.println(A.a3);
		// 受保护的
		System.out.println(A.a4);
		
		
		// 默认
		// System.out.println(B.a1);
		// 公共
		System.out.println(B.a2);
		// 私有
		// System.out.println(B.a3);
		// 受保护的,有继承就可以,没有就不行(同包也可以)
		// System.out.println(B.a4);
	}
}