Day11

一、笔记：

回顾：

匿名对象：没有名字的对象
作用：只对方法进行一次调用时使用

面向对象的三大特征：
封装：
1.将属性私有化
2.提供属性所对应的set get方法

继承：子承父业
使用extends 让类与类之间产生继承关系  

父类：超类  基类  根类  
子类：派生类

子类继承父类后：
1.得到了父类中非私有的一切
2.但是构造器没有继承过来
3.子类在创建对象时，在子类的构造器的第一行会默认调用父类的空参构造器

父类中如果有带参构造器，也是对父类中的属性进行初始化，这时，如果子类想初始化父类中的属性，子类应当将父类中对属性初始化的构造器调用出来

继承的特性：重写
当子类中出现与父类的成员一模一样时，子类会将父类的成员覆盖掉，称为重写。

千万千万千万不要和重载混淆：重载
一个类中可以有多个同名方法，与返回值无关，只要参数列表不同即可。

最后一句话：继承的出现提供了多态的前提

 

多态：一类事物多种表现形态  父类的引用指向子类的对象      
人类：男人 女人
男人是人类的一种:人类 n =new 男人()
女人是人类的一种：人类 n = new 女人()
男人是男人的一种:男人 n = new 男人()
女人是女人的一种：女人 n = new 女人()

猫科类：老虎  豹子  猫  狮子

前提：
1.类与类之间必须有继承关系
2.子类必须重写父类中的方法  

多态的好处：
提高后期代码的可维护性，简化代码。

Object：是java提供的一个类。所有类都必须继承Object类。上帝，盘古
当类没有任何继承关系时，默认继承Object类

boolean  equals(Object o):判断两个对象是否相等,默认比较地址值是否相等。如果想要比较两个对象的属性值，就可以进行重写equals

String toString():直接打印对象其实就是默认调用toString方法。
而toString()的返回值是一个字符串：p.getClass().getName()  + "@" + Integer.toHexString(p.hashCode())

 

抽象：比较模糊，不具体，看不懂的。

父类怎么得来的？
子类的共性不断向上抽取得来的。

关键字：abstract 抽象
类的高级特性---抽象类
有时候，在抽取父类时，只抽取对方法的定义，而方法的具体实现交给子类去完成，这时候抽取出来的类通常定义为抽象类。

抽象类不可以被实例化。
抽象类是为了继承而存在的。
抽象类具有强制性。
抽象类中也可以有不抽象的方法。

子类继承抽象类后，必须重写抽象类中的抽象方法，子类才可以实例化，否则子类也将会是一个抽象类。

 

接口：如果一个抽象类中全部都是抽象方法，这时候就将这个抽象类定义为接口。
简单理解：接口是一个特殊的抽象类。

使用class关键字定义一个类，使用interface定义接口。
类中有：属性、方法、构造器
接口中有：属性和方法

属性和方法有固定格式：
属性：public static final 数据类型 常量名 = 常量值;
方法：public abstract  返回值类型  方法名();

接口是对当前功能的拓展。

子类与父类之间的关系：继承关系 extends
子类与父抽象类之间的关系：形式上是：继承  实际上是：实现 implements
子类与接口之间的关系：实现关系 implements
接口与接口之间的关系：继承关系 extends  而且可以多继承

父类叫子类为：派生类
接口叫子类为：实现类
接口叫继承它的接口：子接口

java中支持单继承，多实现

多态：

基本概念

   多态主要指同一种事物表现出来的多种形态。

语法格式

   父类类型 引用变量名 = new 子类类型();

 

前提：

1.类与类之间必须有继承关系

2.子类必须重写父类的方法(书上说的)

注意事项：

   (1)使用父类的引用指向子类的对象时，父类的引用可以直接调用父类中的成员方法；

   (2)使用父类的引用指向子类的对象时，父类的引用不可以直接调用子类中的成员方法；

   (3)对于非静态的成员方法来说，编译阶段调用父类版本，运行阶段调用子类版本；

   (4)对于静态的成员方法来说，编译和运行阶段调用父类版本，与对象无关；

引用数据类型之间的转换：

(1)引用数据类型之间的转换分为两种：自动类型转换 和 强制类型转换；

     其中子类类型向父类类型的转换发生自动类型转换；

     其中父类类型向子类类型的转换需要强制类型转换；

  (2)引用数据类型之间的转换必须发生在父子类之间，否则编译报错；

  (3)当转换的子类类型并不是该引用真正指向的子类类型时，编译阶段通过，运行阶段

     发生类型转换异常；

  (4)为了避免上述错误的发生，建议每次强制类型转换之前使用以下格式进行判断：

     if(引用变量名 instanceof 目标类型){} 

        - 判断引用变量名真正指向的对象是否为目标类型，若是则返回true，否则返回false

Object类：

•Object类是所有Java类的根基类

•如果在类的声明中未使用extends关键字指明其基类，则默认继承Object类。

•直接打印对象其实是默认调用Object类中的toString()

•重写：toString方法。

–默认返回:包名+类名+@+哈希值

–可以重写！

4种访问权限修饰符：

修饰符	类内部	同一个包	子类	任何地方
private	Yes
(缺省)	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

private ,protected 用来修饰类的成员

private    通常用来修饰属性

public    通常用来修饰方法

protected 受保护的：专门用来给子类使用

final：

基本概念

   final本意为"最终的，不可更改的"，该关键字可以修饰类、成员方法以及成员变量。

 

使用方式

   final关键字修饰类体现在不能被继承；

       - 为了防止滥用继承，如：String类、System类等。

   final关键字修饰成员方法体现在不能被重写；

       - 为了防止不经意间造成方法的重写，如：SimpleDateFormat类中的format()方法。

   final关键字修饰成员变量体现在该成员变量必须初始化而且不能更改；

       - 为了防止不经意间造成数值的改变，如：Thread.MAX_PRIORITY等

扩展：

   在以后的编程中单独使用static或final关键字修饰变量的场合很少，通常都是使用public static final共同修饰该变量来表达常量的含义，常量的命名规则是：所有字母都大写，不同单词之间采用下划线连接。

   如：

       public static final double MY_PI = 3.14;          

对象创建的过程：

单个对象创建的执行过程

   (1)当创建对象时会在堆区中申请内存空间，采用默认初始化的方式来处理成员变量；

   (2)采用显式初始化来进行成员变量的处理；

   (3)执行构造块中的代码，可以给成员变量再次赋值；

   (4)执行构造方法体中的代码，此时对象构造完毕；

子类对象创建的执行过程

   (1)当创建子类对象时会在堆区中申请内存空间；

   (2)先加载父类再加载子类，因此先执行父类的静态语句块，再执行子类的静态语句块；

   (3)先执行父类的构造块，再执行父类的构造方法体，此时父类部分构造完毕；

   (4)先执行子类的构造块，再执行子类的构造方法体，此时子类对象构造完毕；

二、老表  醒醒  代码没敲完  你哪有脸睡觉

1.创建一个名称为Vehicle的接口，在接口中添加两个带有一个参数的方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口。创建一个名称为interfaceDemo的类，在interfaceDemo的main()方法中创建Bike和Bus对象，并访问start()和stop()方法。

package com.qfedu.zhuguangyi.homework;

public interface Vehicle {
	
	void  stop(String s);
	void start(String s);
	
}

package com.qfedu.zhuguangyi.homework;

public class Bike implements Vehicle{


	public void stop(String s) {
		System.out.println("单车停止");
		
	}

	public void start(String s) {
	
		System.out.println("单车启动");
	}
	
	

}

package com.qfedu.zhuguangyi.homework;

public class Bus implements Vehicle{


	public void stop(String s) {
		System.out.println("汽车停止");
		
		
	}


	public void start(String s) {
		
		System.out.println("汽车启动");
	}

}

package com.qfedu.zhuguangyi.homework;

public class interfaceDemo {
	public static void main(String[] args) {
		Bike a=new Bike();
		Bus b=new Bus();
		a.stop("停止");
		a.start("启动");
		b.stop("停止");
		b.start("启动");
		
	
		
	}

}

2.设计一个系统：
 
XXX门的实现过程：
 
流程：
 
设计一张抽象的门Door，那么对于这张门来说，就应该拥有所有门的共性，开门openDoor()和关门closeDoor()；然后对门进行另外的功能设计,防盗--theftproof()、防水--waterproof()、防弹--bulletproof()、防火、防锈…… 要求：利用继承、接口的知识设计该门
 

package com.qfedu.zhuguangyi.homework;

public abstract class Door {
	
	public abstract void openDoor();
	public abstract void closeDoor();

}

package com.qfedu.zhuguangyi.homework;

public  class JiaQiangDoor extends Door implements JieKouDoor{
		
			void theftproof() {
				System.out.println("防盗");
			}
			void waterproof() {
				System.out.println("防水");
			}
			void bulletproof() {
				System.out.println("防弹");
			}
			
			public void fangHuo() {
				
				System.out.println("防 火");
			}
			
			public void fangChong() {
				
				System.out.println("防虫");
			}
			@Override
			public void openDoor() {
				// TODO Auto-generated method stub
				System.out.println("开门");
			}
			@Override
			public void closeDoor() {
				// TODO Auto-generated method stub
				System.out.println("关门");
			}


}

package com.qfedu.zhuguangyi.homework;

public  interface  JieKouDoor {
	void fangHuo();
	void fangChong();
}

package com.qfedu.zhuguangyi.homework;

public class TestJiaQiangDoor {

	
	public static void main(String[] args) {
		JiaQiangDoor J=new JiaQiangDoor();
		J.openDoor();
		J.closeDoor();
		J.theftproof();
		J.bulletproof();
		J.fangChong();
		J.fangHuo();
		
		
		
	}
}

青春只有一次，别让自己过得不精彩！！！