JAVASE_面向对象中

• 代码块：

1. 局部代码块：对局部变量进行初始化
2. 构造代码块：对对象的域进行初始化
3. 静态代码块：对类变量进行初始化

• 抽象类

1. 方法只有声明没有实现，被abstract修饰，该方法就是抽象方法
2. 抽象类不能被实例化，因为抽象类实例化并没有意义可言
3. 抽象类必须有其子类覆盖了其所有的抽象方法后，该子类才能实例化，否则这个子类还是 抽象类。
4. 抽象类仍然可以存在构造函数，用于给子类对象提供初始化
5. 抽象类中也可以不定义抽象方法，但是相对来说比较少见，目的就是不让该类创建对象，java中的适配器就是一个例子

   package 面向对象;
   
   public class 黑马题目 {
   
   		public static void main(String[] args){
   			
   				Person  xh = new Person("小红");
   				Person  xhf = new Person("红爸"){//覆盖空方法
   					public void a(){
   						System.out.print("我会做工作A");
   					}
   					public void b(){
   						System.out.print("我会做工作B");
   					}
   				};
   				Person  xhm = new Person("红妈"){
   					public void c(){
   						System.out.print("我会做工作c");
   					}
   					public void d(){
   						System.out.print("我会做工作d");
   					}
   				};
   				xh.introd();
   				xhm.introd();
   				xhf.introd();
   			
   		}
   }
   
   //定义工作接口
   interface Work{
   	public void a();
   	public void b();
   	public void c();
   	public void d();
   }
   //工作适配器,创建WorkImpl对象是无意义的，我们把
   //适配器类抽象化，使它不能实例化
   abstract class WorkImp implements Work{
   	public void a() {}
   	public void b() {}
   	public void c() {}
   	public void d(){}
   }
   
   //继承工作适配器
   class Person extends WorkImp{
   	private String name;
   	
   	public Person(String name){
   		this.name = name;
   	}
   
   	public String getName() {
   		return name;
   	}
   
   	public void setName(String name) {
   		this.name = name;
   	}
   
   	public void work(){
   		this.a();
   		this.b();
   		this.c();
   		this.d();
   		System.out.println();
   	}
   	
   	public void introd(){
   		System.out.print("大家好!我是："+this.getName()+"  ");
   		this.work();
   	}
   }
   
   
   

   
   
6. 抽象关键字不能和final,peivate,static 等关键字共存
7. 抽象类一定是父类，必须有子类覆盖其抽象方法后才能被实例

• 对象实例化过程:

1. Person p = new Person();
2. JVM首先读取指定路径下的Person.class文件，并把该字节码加载到内存中，并会先加载Person的父类，如果存在其父类的话
3. 在堆内存中开辟空间，分配地址
4. 并在对象空间中，对对象的属性进行默认初始化
5. 调用对象的构造函数进行初始化
6. 在构造函数中，先会默认调用父类的构造函数进行初始化
7. 父类初始化完毕后，再对子类的属性进行显示的初始化
8. 在进行子类构造函数的指定初始化
9. 初始化完成后再把地址值赋值给引用变量

• final关键字

1. final是一个关键字，可以修饰类，方法，变量
2. final修饰的类不能被继承
3. final修饰的方法不能被覆盖
4. final修饰的变量是一个常量，只能够进行一次赋值运算

• 接口

1. 当一个类中的方法都是抽象的时候，这时候就可以将抽象类用另一种形式定义或表示，就是接口interface
2. 接口中定义的变量无论是否带final static修饰，其默认都是final static类型
3. 接口中定义的方法默认都是public abstract，无论你是否书写

   package 接口的使用;
   
   public class Test {
   
   		public static void main(String [] args){
   			Demo1 d1 = new Demo1();
   			d1.show1();
   			d1.show2();
   		}
   }
   interface Demo{
   	public static final int NUM = 4;
   	int NUM1 = 5;//仍然是public static final int NUM1 = 5
   	
   	public abstract void show1();
   	void show2();//任然是abstract，子类必须要实现其方法
   }
   
   class Demo1 implements Demo{
   
   	public void show1() {
   		System.out.println(NUM);
   	}
   	public void show2() {
   		System.out.println(NUM1);
   	}
   	
   }<u>
   </u>//结果:
   4
   5

4. 接口可以继承接口，java为了避免单继承造成的局限性，采用可以实现多个接口，内部类多继承的形式来解决

   package 接口的使用;
   
   public class Test {
   
   		public static void main(String [] args){
   			Demo2 d2 = new Demo2();
   			d2.show1();
   			d2.show2();
   			d2.show3();
   		}
   }
   interface Demo{
   	public static final int NUM = 4;
   	int NUM1 = 5;//仍然是public static final int NUM1 = 5
   	
   	public abstract void show1();
   	void show2();//任然是abstract，子类必须要实现其方法
   }
   
   interface Demo1{
   	public void show3();
   }
   
   class Demo2 implements Demo ,Demo1{
   
   	public void show1() {
   		System.out.println(NUM);
   	}
   	public void show2() {
   		System.out.println(NUM1);
   	}
   	public void show3() {
   		System.out.println("demo3");
   	}
   	
   }
   

• 接口和抽象类的异同点:

1. 相同点是：都是不断向上抽取出来的
2. 不同点是：抽象类必须要被继承，而且只能是单继承，而接口也要被实现，实现可以是多实现
3. 不同点二：抽象类中可以定义抽象方法和非抽象方法，子类继承该抽象类后，可以直接使用其非抽象方法，而接口中只能定义抽象方法，而且其抽象方法必须被子类实现
4. 抽象类的继承是is -a的关系，在定义该体系的基本共性内容，接口的实现是like-a的关系，是在定义该体系的额外功能

   package 接口的使用;
   /**
    * 抽象类：抽取的是类中的共性
    * 接口：抽取的是功能
    * @author Administrator
    *
    */
   public class 抽象类接口的使用 {
   	public static void main(String[] args) {
   		搜爆犬 a = new 搜爆犬(10);//注意采用 犬 a = new 搜爆犬(10);多态性造成
   		System.out.println(a.age);
   		a.搜爆();
   	}
   }
   
   //犬类的定义
   abstract class 犬{
   	int age;
   	public  犬(int age){
   		this.age = age;
   	}
   	abstract void 吼叫();
   }
   //功能的定义
   interface 导盲{
   	void 导盲();
   }
   interface 搜爆{
   	void 搜爆();
   }
   class 导盲犬 extends 犬 implements 导盲{
   	public 导盲犬(int age) {
   		super(age);
   	}
   	public void 导盲() {System.out.println("正在导盲..");}
   	void 吼叫() {}
   }
   class 搜爆犬 extends 犬 implements 搜爆{
   	public 搜爆犬(int age ){ super(age);}
   	public void 搜爆() {System.out.println("正在搜爆..");}
   	void 吼叫() {}
   }