第一讲　　继承　　

1、继承：

　　当多个类拥有相同的功能时，那么这些类不需要每个都写这些相同的功能，只需要把相同功能抽到

一个单独的类中，继承这个类就能获得这些相同的功能；

(1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

• 要了解这个体系结构中最共性的内容,就看最顶层的类。
• 要使用这个体系的功能,就用最底层的类创建对象

（2）好处：

A、提高代码复用性：

B、继承的出现，让类与类之间产生关系，为多态的前提

（3）特点；

A、只能单继承（准确的说是java对多继承进行优化，避免安全问题），可以用多实现解决单继承的局限

B、但能多重继承

（4）注意：

A、子类可以直接访问父类中的非私有属性和行为

B、不要仅仅为了获取部分功能而继承

C、子夫类之间有所属关系才是继承

　　*如何判断A和B是否是继承关系呢？当A继承B时，A is one of B;

2、子类继承父类后成员关系：

（1)成员变量

 1 class Fu{
 2     int num=5;
 3 }
 4
 5 class Zi extends Fu{
 6
 7     int num=20;
 8
 9     public void show(){
10         int num=30;
11         System.out.println("num="+num);//30
12 //        当局部变量与成员变量重名时使用this区分
13         System.out.println("this.num+"+this.num);//答案20
14 //        当字类和父类出现同名变量时，用supeu
15         System.out.println("super.num"+super.num);
16 //    总结：在子类继承夫类中，变量名出现重复，优先级是局部变量——成员变量——父类变量；但是成员可用this父类变量
17 //        用super，来调用
18     }
19 }

（2)成员方法——重载和重写（覆盖，复写）的区别

 1 class Fu{
 2     public void show(){
 3         System.out.println("fu show");
 4     }
 5 }
 6
 7 class Zi extends Fu{
 8
 9     public void show(){
10         System.out.println("zi show");
11     }
12 }
13 /*子类继承父类后，存在于修饰符、方法名、参数列表相同的现象，叫做重写、覆盖、复写
14 重写（override）和重载（overLoad）的区别：
15 重载：
16     在同一个类长
17     方法名相同，参数列表不同
18 重写：
19     在子类继承父类中
20     子类有一个返回类型、方法名、参数相同的方法
21     注：覆盖是，子类的权限大有法雷
22     父类的权限不能私有
23     静态只能覆盖静态
24 */

final作为一个修饰符。具有以下特点：

1、可以修饰类、函数、变量。

2、被final修饰的类不可以被继承。这样就可以避免被继承、被子类复写功能。

3、被final修饰的方法不可以被复写。

4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量

（3）构造方法

 1 class Zi2 extends Fu2{
 2     Zi2(){
 3 //        super();this和super不能一起
 4         this(40);
 5         System.out.println("son");
 6     }
 7
 8     Zi2(int age){
 9         super();//子类中所以的构造方法默认都会访问父类长空参数的构造方法
10         System.out.println("son age:"+age);
11     }
12 }
13
14
15 public class Demo23 {
16     public static void main(String[] args){
17 //        Zi2 z = new Zi2();
18
19         Zi2 z2 = new Zi2(30);
20     }
21 }
22 /*总结：子类中所有构造方法默认有super（）；
23
24     当父类没有空参数的构造方法时，子类的构造函数必须通过this或者
25     super指定眼访问的构造方法。
26
27     构造函数用于创建对象，并初始化；建议你如果写了有参的构造函数，也需要把无参的构造函数协商
28     否则你定义了一个有参数的构造函数，空参数的系统就不会在给了；
29
30 */

以下是类中构造函数的方法实例；

 1 class Person{
 2     int age;
 3     String name;
 4     Person(){}//添加一个空参
 5
 6     Person(int age){
 7         this.age=age;
 8     }
 9     Person(int age,String name){
10         this(age);//代替this.age=age;
11         this.name=name;
12     }
13 }
14     //Person p=new Person();系统默认给出无参构造函数
15 //        当你收到给出构造函数后，系统就不会给出默认的空的构造方法

　第二讲　　抽象类、接口

1、概念：抽象就是从多个事物中将共性的本质的内容抽取出来

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念；

2、特点：

　　A\抽象类和抽象方法必须用abstract修饰

　　B、抽象方法只有声明，没有具体方法

　　C、抽象类不可以实例化，不可以通过new创建对象

　　D、抽象类通过其子类实例化，而子类需要覆盖抽象类所有的抽象方法才能创建对象；

3、与一般类的区别：

　　1、抽象类比一般类至少多一个抽象函数，

　　2，抽象类不能实例化

　　3、抽象类虽然不能创建对象，但是也有构造函数。供子类实例化调用的；

注：被abstract修饰的函数不能同时被private、final,static修饰。

原因：

　　final没有子类，private不能复写，static可以修饰抽象方法，那么连对象都省了，直接调用类名即可；

4、抽象有一个特殊的地方：抽象类中可以不定义抽象方法。这样做可以不让本类实例化，也可以用于模块设计：

 1 abstract class GetTime{
 2
 3     public final void getTime(){//使用final使其不能被复写
 4         long start=System.currentTimeMillis();
 5         propgram();
 6         long end=System.currentTimeMillis();
 7         System.out.println("程序用时"+(end-start));
 8     }
 9     abstract void propgram() ;
10 }
11
12 //子类的程序
13 class program extends GetTime{
14     void propgram() {
15         for(int i=0;i<1000;i++)
16             System.out.println("水音大美女");
17     }
18 }
19
20
21 new program().getTime；

5、接口（interFace）

（1）概念：当一个类长所有的方法都是抽象的时候，定义为接口；

（2）成员的特点：

A、只有成员变量和成员方法；

B、成员变量默认修饰符public static final

　　*int x=20实际上是public static final int x=20；

C：成员方法默认修饰符：public abstract

　　void show()实际上是public abstract void show（）

（3）接口解决了单继承的问题

　　A、类与类只能extend，一次

　　B、接口与接口之间：可以单继承，也可以多继承：extends，implements

　　C、类与接口之间：当实现，也可以多实现：implements

（4）接口的特点：

接口时对外暴露的规则；是功能的扩展；

接口降到了程序的耦合性：

内聚：自己实现功能的能力；

高内聚，低耦合；

举例：USB接口

（5）接口和抽象类的区别：

A：抽象类单继承，接口多实现

B：

　　*抽象类的成员：

　　　　*成员变量：常量或变量

　　　　*成员方法：抽象或非抽象

　　　　*构造方法：可以有，为了给子类实例化用的；

　　*接口的成员

　　　　*成员变量只能常量：默认修饰符：public abstract final

　　　　*成员方法：只能抽象；默认修饰符：public abstract

C:抽象类定义的是体系结构中的共性内容，接口定义的是对象的扩展功能

D：抽象类被继承的表达的是：is a的关系，接口被实现表达的是like a的关系

接口的实例：

 1 //抽象学生类,睡觉和学习是共性的，吸烟是额外的接口的
 2 abstract class Student{
 3
 4 //    抽象学习方法
 5     abstract void study();
 6
 7     void sleep(){
 8         System.out.println("sleep");
 9     }
10 }
11
12 interface Smoking{
13     public abstract void smoke();
14 }
15 //zhangs是继承学生，而实现吸烟
16 class Zhangs extends Student implements Smoking{
17 //    复写学习
18     void study(){
19         System.out.println("zhang_xue");
20     }
21 //    复写吸烟
22     public void smoke(){
23         System.out.println("zahgns_smoke");
24     }
25 }
26 //lili是好学生
27 class lili extends Student{
28 //    复写study即可
29     void study(){
30         System.out.println("lili_study");
31     }
32 }
33
34 //主函数
35     new zhangs().study();
36     new zhangs().smoke();
37     new lili().study();

第三讲　　多态

1、概念：事物存在的多种体系形态；如猫既可以猫科也可以是动物

　　*方法重载（静态多态）：

　　*方法重写（动态多态，对象多态）

2、对象多态的前提

　　A、类与类（接口）有继承或实现关系

　　B、一定要有方法重写（覆盖、复写）

　　C、一定要有父类或接口的引用指向子类的对象

3、多态中成员的特点：例如 Fu f=new Zi();

A:成员变量：编译和运行都看Fu；

B：非静态变量：编译看Fu，运行看Zi；

C：静态方法:编译运行都看Fu；

举例：动物栗子向上转型：Animal a=new cat（）；a。eat();//a.catchMouse();

 1 向下转型
 2 Cat a=(Cat)a;
 3 c.eat();
 4 c.catchMouse();
 5
 6 向上转型
 7 Animal a=new Dog();
 8 //一下错误
 9 Cat c=(Cat)a;
10 Dog d=(Dog)a;

4、多态的好处与弊端：

　　好处：提高程序的扩展性

　　弊端：不能使用子类特有的属性和行为；

5、多态的实例运用;

步骤：1、定义好工具类，即将共有行为封装在一个类中；　　　　

　　　2、对类型进行抽取-————多态的产生

　　　3、操作同一个夫类型，对其中的子类型均可操作

实例小程序：

 1 /*
 2  * 电脑运行实例：电脑的运行由主板控制，上网和听歌需要网卡和声卡额外提供，这是
 3  * 可以定义一个规则，叫做PCI。只有符合这个规则的网卡和声卡都可在主板上使用，这样就降低了主板
 4  * 和网卡、声卡的耦合性
 5  */
 6
 7 //接口PCI
 8 interface PCI{
 9     public abstract void open();
10     public abstract void close();
11 }
12
13 //网卡实现接口
14 class NetCard implements PCI{
15
16     public void open(){
17         System.out.println("Net_open");
18     }
19
20     public void close(){
21         System.out.println("New_close");
22     }
23 }
24
25
26 //声卡实现接口
27 class SoundCard implements PCI{
28
29     public void open(){
30         System.out.println("Sourd_open");
31     }
32
33     public void close(){
34         System.out.println("Sound_close");
35     }
36 }
37 //主板
38 class Mainboard{
39 //电脑运行
40     public static void run(){
41         System.out.println("Mainboard_run");
42     }
43 //    使用扩展功能
44     public static void usePCI(PCI p){//这里参数放的是父类，代表父类和继承父类的类都能放入
45         if(!(p==null)){
46             p.open();
47             p.close();
48         }
49     }
50 }
51
52 class Demo23{
53     public static void main(String[] args){
54         Mainboard m=new Mainboard();
55 //        电脑运行
56         m.run();
57 //        上网
58         m.usePCI(new NetCard());
59 //        听歌
60         m.usePCI(new SoundCard());
61     }
62 }

第四讲　　扩展知识：包、内部类、异常

一、package包，包就是文件夹

1、定义包：使用package关键字在类的第一条语句定义包名，包名全部小写

2、编译带包名的类

　　-javac -d<目录>源文件名.java

　　如：-javac -d.Person.java

3\默认包

　　*如果一个类没有加上package关键字定义包名，它是一个默认的保重，在没有定义包之前默认在一个包中，可以直接访问

　　*如果两个雷定义了包，并且相同的包，可以直接访问

4、运行带包的文件

　　-java 包.类

　　例如：java cn.afs.sf.PackageDemo

5、访问权限

　　private：当前类可以使用

　　默认：同包类可以使用；

　　protected保护：同包中的类和子类可用

　　public 公用的，如果希望被外包使用而添加public，而且public的类必须和文件名一致

6、导入其他包中的类

　　首先该类必须是public　　

　　使用import导入其他包中的类；

　　　　A、*代表所有类　　　　　　如:import java.Lang.*;

　　　　B、写入具体的比较省内存　　　　如:import java.util.Scanner;

7、注意项：

写类的时候要加上包名
类要public, 并且类名和文件名一致
导入类要写类名
编译用-d, 运行带包名

二、内部类：定义在一个类中的类，称为内部类

（1）成员内部类：

　　A：定义：在一个外部类中有成员变量和成员方法，那么成员内部内就是整个一个类当成外部类的成员对待

　　B：访问规则：1、内部类可以直接访问外部类中的成员，包括私有的

　　　　　　　　　　内部类之所以能访问外部类的成员，是因为有引用：外部类名.this.

　　　　　　　　  2、外部类要访问内部类，必须建立对象

（2）访问格式：　　　　Outer.Inner in=new Out().new Inner();

(3）修饰符：final、abstract、public、private、protected和static　　

（4）静态内部类（被static修饰）

　　A、定义在外部类中的内部类加static修饰

　　B、格式：Outer.inner in=new Outer.Inner();

　　C　方法也是静态的：Outer.Inner.Function();

　　记住：静态成员用类名调用的原则就行了

　　注意：内部类的方法静态，那么外部类也必须静态

　　　　　外部类的静态方法不能访问非静态的内部类

（5）局部内部类（在外部类方法中定义内部类，它更像是局部变量）

　　注意：1、不可以被成员变量修饰符修饰：如static

　　　　   2、可以直接访问外部类中的成员，因为用引用；

　　　　　　但是不能访问它所在反复局部的变量，除非该变量被final修饰；

 1 class Outer
 2 {
 3     int x = 3;
 4     void method(final int a)
 5     {
 6         final int y = 4;
 7         //局部内部类
 8                 class Inner
 9         {
10             void function()
11             {
12                 System.out.println(y);
13             }
14         }
15         new Inner().function();//使用局部内部类中的方法。
16     }
17 }
18 class  InnerClassDemo
19 {
20     public static void main(String[] args)
21     {
22         Outer out = new Outer();
23         out.method(7);//打印7
24         out.method(8);//打印8
25     }
26 }  

　　　　　*方法内部类的修饰符。与内部类不同，方法内部类更新一个局部变量。可以用于修饰方法内办理的只有final和abstract

　　　　　*静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能范围外部的静态成员

 1 interface Inter {
 2     public abstract void show1();
 3     public abstract void show2();
 4 }
 5
 6 //有名字的内部类
 7 class Outer {
 8    int x=3;
 9         class Inner implements Inter {
10             int x=4;
11             public void show1(){
12                 x=5;
13                 System.out.println("show1"+x);
14                 System.out.println("show1"+this.x);
15                 System.out.println("show1"+Outer.this.x );
16             }
17
18             public void show2(){
19                 System.out.println("show1");
20             }
21
22     }
23     public void show() {
24         Inter in = new Inner();//父类引用指向子类对象
25         in.show1();
26         in.show2();
27
28     }
29 }

（6）匿名内部类（重点）

　　概念：木有名字的内部类，可以直接定义方法

实例：

 1 //匿名内部类（在android里面用的多，awt的监听器使用较多）
 2 class OuTer{
 3     public void mehtod(){
 4 //        匿名内部类对象调用方法
 5         new Inter(){
 6             public void show1(){
 7                 System.out.println("show1");
 8             }
 9             public void show2(){
10                 System.out.println("show2");
11             }
12         }.show1();
13
14         new Inter(){
15             public void show1(){
16                 System.out.println("show1");
17             }
18             public void show2(){
19                 System.out.println("show2");
20             }
21         }.show2();
22
23     }
24 //    方法2
25     Inter in =new Inter(){
26         public void show1(){
27             System.out.println("show1");
28         }
29         public void show2(){
30             System.out.println("show2");
31         }
32     };
33     in.show1();
34     in.show2();
35 }

使用范围：通常在使用方法是接口类似参数，并该接口中的方法只有1~3个时，可以将匿名内部类作为参数传递

第二讲　　多态

1.概念：

多态可以理解为事物存在的多种体系形式。比如猫，是猫也是动物