Day—10封装，this,static,权限控制

一This

1  this:是每个对象中，保存自身内存地址的一个引用类型变量
 this 表示当前对象
 能做什么： 
    1 ）在成员方法或者构造方法中，区分同名的成员变量和局部变量
                            this.xxx
  2）用在构造方法中，重载调用当前类中其他构造方法，但是必须写在构造方法第一行
             this(xxx)
  3） return this 返回当前对象的内存地址，可以链式调用
  谁调用的这个成员方法，this就是谁 。  注意：this不能使用在静态方法中

	
	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(int year,int month, int day){
		this.year = year;
		this.month = month;
		this.day = day;
	}
	public void print(){
		System.out.println(year + "年" +month + "月" + day+ "日");
	}
	public MyDate(){
//		this.year = 1976;
//		this.month = 7;
//		this.day = 8;
//上面的代码也可以实现，但是偏离代码复用的本事，也影响代码美观和可读性
//调用当前类的指定构造方法
//但是该方法只能写在构造方法中，并且必须是在第一行
		this(1976,7,8);
	}
	

2 链式调用

public static void main(String[] args){
	This_02 p = new This_02();
	p.m1();
	p.m2();
	//链式调用
	p.m1().m2();
}
	public This_02 m1(){
		System.out.println("m1");
		return this;
	}
	public void m2(){
		System.out.println("m2");
	}

注意：This 不能出现在静态上下文中

二 Static

 1修饰符，关键字，用来区分静态和成员

2能做什么 

1 在类体中使用static修饰的变量 使静态变量
2 用static修饰的方法，是静态方法
 3还可以使用static定义静态语句块

3静态语句块

public class Static_01 {
	public static void main(String[] args){
		System.out.println("11111");
		System.out.println(i);
		}
	 //静态变量
	static int i =2;
	//静态方法
	public static void m1(){
		
	}
	//静态语句块，等同于静态方法
	//静态语句块自动执行，在程序加载阶段执行完成，并且只执行一次
	//由于执行时机是在main之前，并且只执行一次，所以非常适合做一些初始化的工作
	//访问一个类的静态属性的时候，类加载
	static {
		System.out.println("2222222222");
	}
	//多个static 语句块，从上往下执行
	static{
		System.out.println("3333333333");
	}

4 实列语句块

实例语句块，可以看作成员方法，没有static修饰的语句块就是成员语句块
创建对象之后，立刻执行，每创建一个对象，就执行一次，并且在构造方法之前

{
		System.out.println("实例语句块1");
	}
	{
		System.out.println("实例语句块2");
	}
	Static_02(){
		System.out.println("构造方法");
	}
	public static void main(String[] args){
		System.out.println("main方法");
		new Static_02();
		new Static_02();
		new Static_02();
	}

}

 三 封装 

  把所有组成部分组合到一起,还可以通过权限控制修饰符将数据隐藏起来,可以控制用户对类数据的修改程度

  适当的封装可以让代码更容易理解,易于维护,更提高了代码的安全性

1包机制

package: 软件包机制
          package: 软件包机制
             1 主要解决了命名冲突问题，在类名前加命名空间
             2 完整的类名是带有包名的，包名.类名 才是这个类的名字
             3 package语句，必须出现在java源文件的第一行
             4 package语句是 规定编译之后的class文件保存的位置和 源文件无关
             5 命名规则 一般采用公司域名倒叙

2 Import

1）import 语句 用于把当前类中需要的其他类 载入
 2）必须出现在class语句之上，package语句之下
 3）java.lang.*  ：改包下所有类均为系统核心类，使用时不需要导入
 注意：按空格 或回车的时候，包会自动导包，如果程序没有问题，但是报错，可以看一下导包是否错误

public static void main(String[] args){
		//因为A和当前类在同包下，所以直接写类名即可找到A
		System.out.println(A.i);
		//只要不在同包下，必须通过    包名.类名 才能找到该类
		
		int i = Ti.age;
	System.out.println(Ti.name);
		
	}

注意： 按空格 或者回车的时候，会导致自动导报，如果程序没问题但是报错的话可以查看一下导包是否错误

import Object.Ti;
//静态导入，把一个类中的静态属性导入，在当前类中可以直接写名字调用，可以省略类名
	
public class Package_02 {
	public static void main(String[] args){
		System.out.println(Ti.age);
		System.out.println(Ti.name);
	}

3权限控制

 public : 公共的， 哪里都能访问

private：只能在当前类访问

default：不写权限控制符，默认为default ，同包中即可访问

protected：受保护的，继承权限，要么同包，要不有继承关系

public class Q_01 {
	public static void main(String[] args){
		//同包测试
		//公共的, 行
		System.out.println(Q.a);
		//私有的,不行
	//	System.out.println(Q.b);
		//默认的  行
		System.out.println(Q.c);
		//受保护的  行
		System.out.println(Q.d);
		
		//不同包测试
		//公共的, 行
		System.out.println(W_01.a);
		//私有的  不行
	//	System.out.println(W_01.b);
		//默认的  不行
	//	System.out.println(W_01.c);
		//受保护的  不行
	//	System.out.println(W_01.d);
	}

4 继承

1） 继承：就是在已有的类中派生出新的类，新的类能吸收已有的类的属性和行为

java中 只支持单继承，不支持多继承，并且继承可以传递

一个类中只能继承一个父类，但是一个类中可以被很多子类继承

2）继承目的：代码复用，提高效率，如果父类满足不了子类需求的话，还可以进行覆写，可以使用多态，        

如果一个类中没有显示继承一个类，那么该类默认继承 Object

java.lang.Object 是Java中提供的根类 ，所有类都会直接 或者间接性的继承这个类

3）语法  ：  class类名  extends   父类名  { 类体 }

 

 

 5 Super

1）super: 官方说法：代表了父类的特征

2） 用在成员方法和构造方法中，区分子类之间同名的方法和变量

                        super.xxx        

3)用在子类构造方法中，调用指定的父类构造方法

                super(xxx)

 如果在子类构造方法中，没有显示出现 super()  也没有出现this(xxx) 则默认有一个super()  调用父类无参构造，并且 super(xxx) 必须出现在子类构造方法第一行，所以 this(xxx) 和 super(xxx) 不能同时出现

public class Father {
	int age =18;
	String name = "张三";

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

public class Son extends Father {
	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);
		
	}

注意：

如果在子类构造方法中,没有显示出现super() 也没有出现 this(xxx)  则 默认有一个super() 调用父类无参构造，并且 super(xxx) 必须出现在子类构造方法 第一行  所以 this(xxx) 和 super(xxx) 不能同时出现。因为构造方法第一行有super()调用父类构造,所以 某一个类如果构造方法私有化了,那么该类不会再被继承

6覆写/重写

 写一个 和父类一样的方法，但是功能不一样

1 方法名  返回值  参数列表  必须和父类一致

2 不能比原方法拥有更低的访问权限

3不能比原方法拥有更宽泛的异常

覆写  特指成员方法，也就是只有成员方法可以覆写