标签：
(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.概念：
黑马程序员——Java基础——面向对象——继承、抽象类、接口、多态、包、内部类、异常等
标签：
原文地址：http://www.cnblogs.com/shuiyinmeizi/p/4196473.html
