一．构造函数

说明：是类的一种特殊的方法。

作用：完成对新对象的初始化。

特点：1.方法名和类名相同

           2.没有返回值

          3.在创建一个类的新对象时，系统会自动的调用该类的构造方法完成对新对象的初始化

          4.一个类可以有多个构造函数

          5.每个类都有一个默认的构造函数

public class Demo1{public static void main(String []args){}//定义一个人类class Person{int age;String name;//构造函数1public Person(int age,String name){age=age;name=name;}//构造函数2public Person(int age){name=name;}}}

二．继承

说明：当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类的中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过关键字extends,来声明子类继承父类，这样子类就会拥有父类定义的某些属性方法。

作用：解决代码复用的问题。

特点：1.public、protected、默认方式的属性和方法可以被继承

          2.子类最多只能继承一个父类

          3.java所有的类都是Object类的子类

package com.abc;public class Demo2{public static void main(String args[]){Pupil p1=new Pupil();p1.printname();}}//学生类（父类）class Stu{protected int age;public String schoolId;public String name;public float fee;public void printName(){System.out.println("名字"+this.name);}}//小学生类class Pupill extends Stu{public void pay(float fee){this.fee=fee*0.8f;}}//中学生类class MiddleStu extends Stu{public void pay(float fee){this.fee=fee;}}

三．重载

说明：重载就是在类中的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者各处的参数。

特点：一个类中有多个方法名相同的方法，但这些方法的参数不同。

例子：一个游戏不确定是单人玩还是双人玩时，根据玩家不同而自动调用不同的方法。

public class Demo3{	public static void main(String []args){		Abc2 abc1=new Abc2();		System.out.println(abc1.getMax(12,14));		System.out.println(abc1.getMax(24f,20f));	}}class Abc2{	//返回较大的整数	public int getMax(int i,int j){		if(i>j){			return i;		}else{			return j;		 }	}	public float getMax(float a,float b){		if(a>b){			return a;		}else{			return b;		 }	}

四．覆盖

说明：覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样。

特点：父类有一个方法，子类继承这个父类，自己也有一个方法，这个方法和父类的方完全一样，否则编译出错。

例子：一个动物父类，一个子类狗类，一个子类猫类。动物父类里有个叫的方法，子类也有一个叫的方法，不过它是汪汪的叫，猫类是喵喵的叫。

public class Demo4{	public static void main(String []args){		//创建一只猫		Cat cat1=new Cat();			cat1.cry();		Dog dog1=new Dog();			dog1.cry();	}}//动物类class Animal{	int age;	String name;	//都会叫	public void cry(){		System.out.println("我是动物，不知道怎么叫");	}}//猫猫类class Cat extends Animal{	//覆盖父类方法	public void cry(){		System.out.println("猫猫叫!");	}}//狗狗类class Dog extends Animal{	//覆盖父类方法	public void cry(){		System.out.println("汪汪叫!");	}}

五．多态

说明：允许不同类的对象对同一消息做出响应。及同一消息可以根据发送对象的不同而采用多种不同的行为方式。

作用：消除类型之间的耦合关系、可替换性、可扩充性、接口性、灵活性、简化性。

特点：1.要有继承

           2.要有重写

           3.父类引用指向子类对象

例子：按下F1键这个动作，如果当在PS软件界面下，弹出网页版的帮助，而在word下弹出word帮助文档，在windows下弹出windows帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

//演示继承、方法覆盖、多态public class Demo5{	public static void main(String[] args) {		//非多态演示		Cat cat=new Cat();		cat.cry();		Dog dog=new Dog();		dog.cry();		//多态演示		Animal an=new Cat();		an.cry();		an=new Dog();		an.cry();	}}//动物类class Animal{	String name;	int age;	public String getName() {		return name;	}	public void setName(String name) {		this.name = name;	}	public int getAge() {		return age;	}	public void setAge(int age) {		this.age = age;	}	//动物会叫	public void cry(){		System.out.println("不知道怎么叫");	}}//创建Dog子类并继承Animal父类及覆盖cry方法class Dog extends Animal{	//狗叫	public void cry(){		System.out.println("汪汪叫");	}}class Cat extends Animal{	//猫自己叫	public void cry(){		System.out.println("猫猫叫");	}}

六．抽象

说明：可以用abstract关键字来修饰的方法或类。

作用：当父类的一些方法不能确定时，可以用abstract解决。

特点：1.抽象类不能被实例化

           2.抽象类可以没有abstract抽象方法

           3.一旦类包含了abstract抽象方法，则这个类必须声明为abstract抽象类

           4.抽象方法不能有主体，例如：abstract  void void abc();

//抽象类的必要性[Demo6.java]public class Demo6{	public static void main(String[] args) {		//Animal an=new Animal();抽象类不允许实例化		Animal an=new Cat();		an.cry();		an=new Dog();		an.cry();	}}//抽象类abstract关键词abstract class Animal{	String name;	int age;	//动物会叫，使用了abstract抽象方法	abstract public void cry();//抽象类中可以没有abstract抽象方法	//抽象类内可以有实现方法	public void sx(){		System.out.println("实现方法");	}}//当一个子类继承的父类是abstract抽象类的话，需要程序员把抽象类的抽象方法全部实现。class Cat extends Animal{	//实现父类的cry，其实类似上节学习中的子类覆盖父类	public void cry(){		System.out.println("猫猫叫");	}}class Dog extends Animal{	//实现父类的cry，其实类似上节学习中的子类覆盖父类	public void cry(){		System.out.println("汪汪叫");	}}

七．接口

说明：英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。   

作用：体现了程序设计的多态和高内聚低耦合的设计思想。

特点：1.接口不能被实例化

           2.接口中所有的方法都不能有主体（不能有大括号）。

           3.一个类可以实现多个接口

           4.接口中的变量会被隐式地指定为public static final 变量（只能是这个），方法会 被隐式地指定public abstract 方法（只能是这个）。根据这个特性，我们经常把常用的变量定义在接口中，作为全局变量使用（访问形式： 接口名.变量名）。

//接口的实现[Demo7.java]//电脑，相机，u盘，手机//usb接口interface Usb{	int a=1;//加不加static都是静态的，不能用private和protected修饰	//声明了两个方法	public void start();//接口开始工作	public void stop();//接口停止工作}//编写了一个相机类，并实现了usb接口//一个重要的原则：当一个类实现了一个接口，要求该类把这个接口的所有方法全部实现class Camera implements Usb{	public void start(){		System.out.println("我是相机，开始工作了..");	}	public void stop(){		System.out.println("我是相机，停止工作了..");	}}//编写了一个手机，并实现了usb接口class Phone implements Usb{	public void start(){		System.out.println("我是手机，开始工作了..");	}	public void stop(){		System.out.println("我是手机，停止工作了..");	}}//计算机class Computer{	//开始使用usb接口	public void useUsb(Usb usb){		usb.start();		usb.stop();	}}public class Demo7 {	public static void main(String[] args) {		System.out.println(Usb.a);		//创建 Computer		Computer computer=new Computer();		//创建Camera		Camera camera1=new Camera();		//创建Phone		Phone phone1=new Phone();		computer.useUsb(camera1);		computer.useUsb(phone1);}

八．final

说明：类型修饰符，用来修饰类、方法和变量。

作用：1.当不希望类被继承时

           2.当不希望父类的某个方法被子类覆盖时。

           3.当不希望类的某个变量的值修改时。

//final方法的使用[Demo8.java]public class Demo8 {	public static void main(String[] args) {		Aaa aaa=new Aaa();		aaa.show();		Bbb bbb=new Bbb();		bbb.show();	}}class Aaa{ 	int a=0;//如果a不赋初值,a是0。定义类型后应赋值	//圆周率不让修改	//带有final修饰的变量命名时应有_下划线来区分表示。这是java程序员的标准。	final float reate_1=3.1415926f;//使用final可以保证，需要强制不被修改的数据一定要用final锁定	//final int b;  //使用final定义变量时一定要赋初值否则报错。	//b=1;	final public void sendMes(){//给成员方法用final来修饰则表示不可以被修改，不可被覆盖。		System.out.println("发送消息");	}	public void show(){		System.out.println("a="+a);	}}final class Bbb extends Aaa{//定义类前加final表示该类不允许被继承	public Bbb(){		a++;		//reate_1=reate+1;	}	/*public void sendMes(){		System.out.println("发送消息")	}*/}