面向对象的高阶特征

访问权限修饰符

publlic:公共的 表示谁都可以使用的
protected:受保护的 只有本包内可以访问 + 包外有继承关系的子类中可以访问
default:默认的 只有本包内可以访问
private:私有的 只有本类可以访问

• 各自能修饰符什么:

   					类		成员
   public： 			T			F
   protected 			F		    T
   default 			T 			T
   private			F			T
  

• 面试题：

A类里面定义一个public修饰的方法 在B类里面能使用吗？
如果B想要访问A类里面公共的方法 需要B类先可以访问A类
如果A类可以被B访问到 那么可以访问A里面的公共方法。
如果A类访问不到B类里面的方法 那么也不能访问A里面的公共方法。

static修饰符

static修饰符：静态的

static能修饰哪些东西？

• 属性：
  静态属性 表示整个类型共享一份的属性 不是每个对象都有一份的属性。
  需要拿着类名.静态属性
  普通属性需要拿着对象.普通属性
  比如：System.out

static为什么不能修饰局部变量？
static修饰的变量要求类一加载就要在内存里面找到他，但是局部变量只有方法调用，代码执行到那一行才能创建，类的加载永远在前面 ，方法调用永远在后面 这两个时间点赶不上一起的，所以static不能修饰局部变量。

• 方法：
  静态方法 需要拿着类名去调用 静态方法里面只能直接的访问静态的成员。

public class TestStatic3{
	public static void main(String[] args){
		A aa = new A();
		aa.test();
		aa.show();
	}
}

class A{

	int x = 10;//实例属性 ： 依赖于对象存在				对象.x
	static int y = 90;//静态属性： 依赖于类存在			对象.y    A.y
	/**
		test():普通方法
		既可以直接的调用静态成员 也可以直接的调用非静态元素
	*/
	public void test(){//实例方法：依赖于对象存在		对象.test()
		//代码执行到这一行.....
		//test()被调用了
		//内存里面有A类对象
		System.out.println(x);//x = this.x
		System.out.println(y);
	}
	/**
		静态方法：里面只能直接的调用静态的成员
		如果想要在静态方法里面访问非静态的成员
		需要创建对象 拿着对象去访问
	*/
	public static void show(){//静态方法 依赖于类存在		对象.show()   类名.show()
		//代码执行到这一行
		//show()被当调用了
		//不能表示底层里面一定有A类对象

		A aa = new A();
		System.out.println(aa.x);
		System.out.println(y);
	}
}
/**打印输出
10
90
10
90
*/

• 代码块：
  初始化一个普通属性的
  如果想要初始化静态属性 需要使用静态代码块 -》 static{}
  普通代码块：当创建对象的时候执行 创建几个对象执行几次
  静态代码块：当类第一次被加载的时候执行 从头到尾执行一次

单例模式

• 醉汉式 饿汉式

1、私有化构造方法
2、创建一个私有的 静态的 属于本类类型的对象
3、提供一个公共的 静态的 返回本类对象的方法
static:防止出现死循环嵌套：

public class Singleton2{
	public static void main(String[] srtfge){
		Moon x = Moon.getMm();
		Moon y = Moon.getMm();
		System.out.println(x == y);
	}
}
//单例模式之饿汉式[醉汉式]
class Moon{
	//private:防止外界随意的创建对象
	private Moon(){}
	//private:防止外界随意的修改mm的值
	//static:防止出现死循环嵌套
	private static Moon mm = new Moon();
	//public:封装的要求
	//static:防止方法依赖于对象存在
	public static Moon getMm(){
		return mm;
	}
}

//懒汉式
class Sun{
	private Sun(){}
	private static Sun only;

	public static synchronized Sun getOnly(){//加锁
		if(only == null){//A 时间片
			only = new Sun();
			return only;
		}else{
			return only;
		}
	}
}
//打印输出true

• 懒汉式

尚不完善

final修饰符

final可以修饰什么

• 类：
  最终类 “骡子类” 不能有子类 但是可以有父类
  String类和Math类都是最终类

• 方法：
  最终方法 可以被继承 不能被覆盖

• 变量
  [属性 + 局部变量] 最终变量 常量 ：一旦赋值之后就不能在再修改值
  final修饰基本数据类型 ：数值不变
  final修饰引用数据类型 ： 地址不变

public class TestFinal1{
	public static void main(String[] args){
		B bb = new B();
		bb.test();
	}
}

class A{
	public final void test(){
		System.out.println("A类的test");
	}
}

class B extends A{
	//test()
	@Override
	public void test(){
		System.out.println("B类的test");
	}
}
/**
被覆盖的方法为final
1 个错误

Tool completed with exit code 1
*/

abstract修饰符

abstract可以修饰哪些东西？

• 类：
  抽象类 表示这个类型不形象不具体 不能创建对象。
  面试题:抽象类是类吗？
  是
  抽象类有构造方法吗？
  有，Java中只要是个类就一定有构造方法
  抽象类的构造方法什么作用？
  给子类构造方法首行的super()使用的。

• 方法：
  抽象方法表示这个类型一定会这个方法，但是现在给不出具体的实现，待留给子类去实现。
  一个类里面只要出现了抽象方法，那么这个类一定要变成抽象类。
  抽象类里面既可以定义抽象方法，`也可以定义普通方法。

public class TestAbstract1{
	public static void main(String[] args){
		Cat cc = new Cat();
		Dog dd = new Dog();
		cc.eat();
		dd.eat();
	}
}

abstract class Animal{
	public abstract void eat();

	public void sleep(){
		System.out.println("动物需要休息");
	}
}
class Cat extends Animal{
	@Override
	public void eat(){
		System.out.println("猫吃鱼");
	}
}
class Dog extends Animal{
	@Override
	public void eat(){
		System.out.println("狗吃肉");
	}
}
/**
打印输出：
猫吃鱼
狗吃肉
*/
/*
abstract class Animal{
	public Animal(){}
}//动物

class Cat extends Animal{
	public Cat(){
		super();
	}
}*/