java中的访问权限，向上造型、重写，抽象概念

1.protected:受保护，修饰的成员变量或方法，只适合本类，子类，同包类
2.public:本类，子类，同包类，挎包类；
3.private:只适合于本类
4.默认：只适合本类，子类，同包类

import:同包中的类可以直接访问，不同包中的类不能直接访问，想访问有两种方式：
1.先import声明类，再访问—建议使用
2.类的全称（包名+类名）—不建议使用（繁琐）

public class A00 {
	protected int x;
	protected int y;
	public A00(){
		this.x=x;
		this.y=y;
	}
	public static void main(String[] args) {
		A00 p=new A00();
		int a=p.x;
		int b=p.y;
		System.out.println(a+"  "+b);
	}
}

执行结果为0，0

public class Bank extends person{
	public static void main(String[] args) {
		Bank bank=new Bank();
        //String id=bank.id;
		String pwld=bank.password;
		System.out.println(pwld);
        //bank.test();
	}
}
class person{
	private String id;
	String password;
	
	public person(){
		this.id="2652+6526";
		this.password="123456";
		System.out.println("lal"+id);
	}
	private void test(){
		System.out.println(id);
	}
}

当主方法中执行String id=bank.id；或者bank.test();时会发生编译错误，因为id这个属性和test（）这个方法都封装为私有的无法被别的类使用或者调用。

1.父类的引用指向子类的对象
2.能点出来什么看引用类型

public class b00 extends c00{
	int a;
	int b;
	
	public void test(){
		System.out.println("这是b00中的test（）方法");//方法的重写
	}
	
	public static void main(String[] args) {
		b00 a=new b00();
		//父类---->子类
		c00 b=new b00();//向上造型
		b.test();//重写方法被调用时，看对象类型
	}
}
class c00{
	int m;
	int n;
	public void test(){
		System.out.println("这是co0中的test（）方法");
	}
}

执行boo类中的test方法

​ 1.发生在父子类中，方法签名相同（方法名，参数列表都相同），方法体不同。
​ 2.重写方法被调用时，看对象类型
​ 3.重写要遵循“两同两小一大”原则{
​ 两同： 参数列表相同，方法名相同
​ 两小：1.派生类的返回值类型小于或者等于超类的返回值类型；
​ 1.void时，必须相同
​ 2.基本类型时必须相同、
​ 3.引用类型时小于或者等于
​ 2.派生类所抛出的异常小于或者等于超类
​ 一大：派生类方法的访问权限大于或者等于超类

public class Pdd extends Uzi{
	public Pdd test(){//如果public是private的话，则会发生编译错误
		return new Pdd();
	}
}
class Uzi{
	public Uzi test(){
		return new Uzi();
	}
}

1.重写（Override）
1.发生在父子类中，方法签名相同（方法名，参数列表都相同），方法体不同
2.遵循“运行期”绑定，看对象的类型来帮定方法
2.重载（Overload）
1.发生在一个类中，方法名相同，参数列表不同，方法体不同
2.遵循“编译期”绑定，看参数类型来绑定方法

1.有abstract修饰
2.只有方法定义，没有方法的实现
3.抽象类不能被实体化
4.包含抽象方法的类必然是一个抽象类，不包含抽象方法的类也可以定义为抽象类。

1.有abstract修饰
2…包含抽象方法的类必然是一个抽象类，不包含抽象方法的类也可以定义为抽象类
3.抽象类不能被实体化
4.抽象类要被继承（派生类）；
4.1重写所有的抽象方法—把父类中的方法由不完整变成完整
4.2也可以声明为抽象类—不建议使用（没有意义）
5.抽象类的意义：
5.1封装派生类所有的属性和行为-----代码反复
5.2为所有派生提供统一类型--------向上造型
5.3可以包含所有抽象方法，为所有派生类提供统一的入口，派生类的行为不一样，但是入口一致。

public class DemoAbstrat extends Doo{
	public void test(){
		System.out.println("DemoAbstrat中的test（）方法");
	}
	
	public static void main(String[] args) {
		Doo d=new DemoAbstrat();
		d.test();
		Doo d1=new Foo();
		d1.test();
		
		//Doo p=new  Doo();
	}
}


class Foo extends Doo{
	public void test(){
		System.out.println("Foo中的test（）方法");
	}
}
 
abstract class Doo{//抽象类
	public int a;
	public int b;
	public abstract void test();//抽象方法
}

如果Doo p=new Doo();会发生编译错误，抽象类不能被实体化