面向对象(下)
2014-04-12 10:22
330 查看
知识点汇总
1.继承
1.1 继承的概念:
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
多个类可以称为子类,单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
示例:class SubDemo extends Demo{}
继承的作用:
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系,提供了多态的前提。
1.2 继承的特点:
Java只支持单继承,不支持多继承。
一个类只能有一个父类,不可以有多个父类。
class SubDemo extends Demo{}
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
定义继承需要注意:
不要仅为了获取其他类中某个功能而去继承
类与类之间要有所属( " is a " )关系,xx1是xx2的一种。
代码示例:
1.3 super关键字
super和this的用法相像
this代表本类对象的引用
super代表父类的内存空间的标识。也就是父类对象的引用
当子父类出现同名成员时,可以用super进行区分
子类要调用父类构造函数时,可以使用super语句。
代码示例:
1.4 函数覆盖
子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为重写或者复写。
1.5 函数覆盖的注意事项
父类中的私有方法不可以被覆盖。
在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名获取。
覆盖时,子类方法权限一定要大于等于父类方法权限
静态只能覆盖静态。
1.6 子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数,因为每个构造函数的第一行都有一条默认语句super();
先执行父类中没有被子类覆盖的方法,然后执行子类中覆盖父类的新方法。
代码示例:
1.7 final关键字
final可以修饰类,方法,变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。
1.8 抽象类
定义:Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。
1.9 抽象方法
多个对象都具备相同的功能,但是功能的具体内容有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。
抽象方法的格式:
修饰符 abstract 返回值类型 函数名(参数列表) ;
1.10 抽象类的特点:
抽象类不可以实例化,通过子类来创建对象(这个在后面中经常用到)
抽象类和抽象方法必须用abstract关键字修饰
抽象类通过其子类实例化,而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象,否则该子类也是抽象类。
代码示例:
1.11 接口
接口的格式:interface{}
接口中的成员修饰符是固定的。
成员常量:public static final
成员函数:public abstract
发现接口中的成员都是public的。
接口的出现将“多继承”通过另一种形式体现出来,即“多实现”。
1.12 接口的特点
接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性。
接口可以用来多实现。
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
代码示例:
1.13 接口与抽象类
共性:
接口与抽象类都是抽象出来的概念
区别:
抽象类体现继承关系,一个类只能单继承
接口体现实现关系,一个类可以多实现
抽象类是继承,是 "is a "关系
接口是实现,是 "like a"关系
抽象类中可以定义非抽象方法,供子类直接使用
接口的方法都是抽象,接口中的成员都有固定修饰符
2.多态
2.1 定义:某一类事物的多种存在形态。
程序中体现:
父类或者接口的引用指向或者接收自己的子类对象。
好处:
多态的存在提高了程序的扩展性和后期可维护性
弊端:
只能使用父类的引用访问父类中的成员。
前提:
需要存在继承或者实现关系
要有覆盖操作
引用类型提升:
父类引用指向子类对象,这种情况就是类型提升,向上转型
父类引用指向子类对象时,该引用可以被提升,也可以被向下转型。
2.2 多态的特点
成员函数:编译时,看左边,运行时,看右边。
编译时:要查看引用变量所属的类中是否有所调用的成员。
在运行时:要查看对象所属的类中是否有所调用的成员。
成员变量:只看左边
只看引用变量所属的类。
代码示例:
2.3内部类
定义:将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
访问特点:
内部类可以直接访问外部类中的成员,包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
为什么内部类可以直接访问外部类中的成员呢?
那是因为内部中都持有一个外部类的引用。这个引用是 外部类名.this.
内部类的特点:
内部类定义在成员位置上
可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量,但必须是被final修饰的。
外部类访问内部类方式:
1,当内部类定义在外部类成员位置上,而且非私有。在外部类其他类中,可以直接建立内部类对象。
格式:
外部类名.内部类名 变量名 = 外部对象.内部对象;
Outer.Inner in = new Ouert().new Inner();//这种方法很少用
2,当内部类出现在成员位置上就可以被成员修饰符所修饰
例如:private:将内部类在外部类中进行封装;
static:内部类就具备static的特性
当内部类被static修饰后,只能直接访问外部类中的static成员,访问受到了限制
在外部其他类中,如何直接访问static内部类的非静态成员的呢?
new Outer.Inner().function();
如何直接访问staitc内部类的静态成员呢?
Outer.Inner.funtion();
当外部类中的静态方法访问内部类时,内部类必须是静态的
当内部类中定义了静态成员,该内部类必须是静态的
代码示例:
2.4 匿名内部类
匿名内部类就是内部类的简化写法。
前提:
内部类可以继承或实现一个外部类或者接口。
格式为:
new 外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
简单理解:
就是建立一个带内容的外部类或者接口的子类匿名对象。
代码示例:
Object类中的equals()方法和toString()方法
equals():用于比较两个对象是否相等,实际上是比较两个对象的引用类型变量中存储的地址值是否相等
根据对象的属性不同,判断对象是否相同的具体内容也不一样。所以在定义类时,一般都会复写equals方法。
toString():Object类提供的toString方法总是返回该对象实现类的“类名+@+hashCode”值,这个返回值并不能真正实现“自我描述”的功能,因此如果用户需要自定义类能实现“自我描述”的功能,就必须重写Object类的toString方法。
equals()和“==”的区别
equals():是方法,用来比较对象的内存地址值,是引用型变量间的比较
== :是运算符,可用于基本数据类型间比较,比较的是数值
也可用于引用数据类型的比较,比较的是内存地址值
代码示例:
toString():Object类提供的toString方法总是返回该对象实现类的“类名+@+hashCode”值,这个返回值并不能真正实现“自我描述”的功能,因此如果用户需要自定义类能实现“自我描述”的功能,就必须重写Object类的toString方法。
代码示例:
3. 包(package)
3.1 包的概述
对类文件进行分类管理。
给类提供多层命名空间。
写在程序文件的第一行。
类名的全称的是 包名.类名。
包也是一种封装形式。
3.2 包之间的访问
被访问的包中的类权限必须是public的。
类中的成员权限:public或者protected
protected是为其他包中的子类提供的一种权限
3.3 四种权限
3.4 import
简化类名。
一个程序文件中只有一个package,可以有多个import。
用来导包中的类,不导入包中的包。
3.5 jar包
jar包的概述:
Java的压缩包
方便项目的携带。
方便于使用,只要在classpath设置jar路径即可。
3.6 jar包的操作
通过jar.exe工具对jar的操作。
创建jar包
jar -cvf mypack.jar packa packb
查看jar包
jar -tvf mypack.jar [>定向文件]
解压缩
jar -xvf mypack.jar
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
1.继承
1.1 继承的概念:
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
多个类可以称为子类,单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
示例:class SubDemo extends Demo{}
继承的作用:
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系,提供了多态的前提。
1.2 继承的特点:
Java只支持单继承,不支持多继承。
一个类只能有一个父类,不可以有多个父类。
class SubDemo extends Demo{}
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
定义继承需要注意:
不要仅为了获取其他类中某个功能而去继承
类与类之间要有所属( " is a " )关系,xx1是xx2的一种。
代码示例:
class Person { String name; int age; } class Student extends Person { {//构造代码块;此语句中的name和age继承父类得来 System.out.println("name:"+name+"...age:"+age); } public static void info(String name, int age) { System.out.println("name:"+name+"...age:"+age); } } class ExtendsDemo { public static void main(String[] args) { Student s = new Student(); s.info("lisi",21); } }
1.3 super关键字
super和this的用法相像
this代表本类对象的引用
super代表父类的内存空间的标识。也就是父类对象的引用
当子父类出现同名成员时,可以用super进行区分
子类要调用父类构造函数时,可以使用super语句。
代码示例:
/** super关键字 super代表父类对象的引用 super用于构造函数间的调用 */ class Person { String name; int age; Person(String name,int age) { this.name = name; this.age = age; } } class Student extends Person { Student(String name,int age) { super(name,age);//通过super调用父类中构造器的初始化 } } class Teacher extends Person { double height; Teacher(String name,int age,double height) { super(name,age); this.height = height; } } class SuperKeyWord { public static void main(String[] args) { Student s = new Student("lisi",22); Teacher t = new Teacher("zhangsan",98,171.1); System.out.println("name:"+t.name+"...age:"+t.age+"...height:"+t.height); } }
1.4 函数覆盖
子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为重写或者复写。
1.5 函数覆盖的注意事项
父类中的私有方法不可以被覆盖。
在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名获取。
覆盖时,子类方法权限一定要大于等于父类方法权限
静态只能覆盖静态。
1.6 子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数,因为每个构造函数的第一行都有一条默认语句super();
先执行父类中没有被子类覆盖的方法,然后执行子类中覆盖父类的新方法。
代码示例:
/** 覆盖 需求:写一个表现覆盖特性的程序 分析: 首先要定义一组子父类 子类复写父类中的方法 思路: 父类:Person;子类:student 子类方法:run(){“zi run”}父类方法run(){"fu run"} */ class Person { void run()//Person类中的run方法 { System.out.println("Person run"); } } class Student extends Person { void run()//Student类中的run方法 { System.out.println("Student run"); } } class OverWriteDemo { public static void main(String[] args) { Student s = new Student(); s.run();//此时输出的是student中的run方法 } }
1.7 final关键字
final可以修饰类,方法,变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。
1.8 抽象类
定义:Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。
1.9 抽象方法
多个对象都具备相同的功能,但是功能的具体内容有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。
抽象方法的格式:
修饰符 abstract 返回值类型 函数名(参数列表) ;
1.10 抽象类的特点:
抽象类不可以实例化,通过子类来创建对象(这个在后面中经常用到)
抽象类和抽象方法必须用abstract关键字修饰
抽象类通过其子类实例化,而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象,否则该子类也是抽象类。
代码示例:
/** 抽象类和抽象方法 需求:写一个演示抽象类和抽象方法特点的程序 分析: 写一组子父类 父类中有抽象方法,父类是抽象类 子类覆盖父类中的抽象方法 思路: 父类:Person;子类:student,teacher 抽象方法:abstract work(); 在子类中定义work()覆盖 */ abstract class Person//抽象类 { abstract void work();//抽象方法 } class Student extends Person { void work()//复写父类中的work抽象方法 { System.out.println("study"); } } class Teacher extends Person { void work() { System.out.println("teach"); } } class AbstractDemo { public static void main(String[] args) { Student s = new Student(); s.work(); Teacher t = new Teacher(); t.work(); } }
1.11 接口
接口的格式:interface{}
接口中的成员修饰符是固定的。
成员常量:public static final
成员函数:public abstract
发现接口中的成员都是public的。
接口的出现将“多继承”通过另一种形式体现出来,即“多实现”。
1.12 接口的特点
接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性。
接口可以用来多实现。
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
代码示例:
interface A { public static final int a = 1; public abstract void getA(); } interface B { public static final int b = 2; public abstract void getB(); } interface C extends A,B//接口支持多继承 { public static final int c =3; public abstract void getC(); } class InterfaceDemo { public static void main(String[] args) { System.out.println(C.a); System.out.println(C.b); System.out.println(C.c); } }
1.13 接口与抽象类
共性:
接口与抽象类都是抽象出来的概念
区别:
抽象类体现继承关系,一个类只能单继承
接口体现实现关系,一个类可以多实现
抽象类是继承,是 "is a "关系
接口是实现,是 "like a"关系
抽象类中可以定义非抽象方法,供子类直接使用
接口的方法都是抽象,接口中的成员都有固定修饰符
2.多态
2.1 定义:某一类事物的多种存在形态。
程序中体现:
父类或者接口的引用指向或者接收自己的子类对象。
好处:
多态的存在提高了程序的扩展性和后期可维护性
弊端:
只能使用父类的引用访问父类中的成员。
前提:
需要存在继承或者实现关系
要有覆盖操作
引用类型提升:
父类引用指向子类对象,这种情况就是类型提升,向上转型
父类引用指向子类对象时,该引用可以被提升,也可以被向下转型。
2.2 多态的特点
成员函数:编译时,看左边,运行时,看右边。
编译时:要查看引用变量所属的类中是否有所调用的成员。
在运行时:要查看对象所属的类中是否有所调用的成员。
成员变量:只看左边
只看引用变量所属的类。
代码示例:
/** 多态演示 分析: 定义动物类 猫类 狗类 动物类中定义吃东西的抽象方法 猫类中定义猫吃东西的方法和抓老鼠的方法 狗类中定义狗吃东西的方法和看家的方法 猫类和狗类继承动物类 分别调用猫和狗吃东西的方法 调用猫抓老鼠的方法 调用狗看家的方法 */ abstract class Animal { public abstract void eat(); } class Cat extends Animal { public void eat() { System.out.println("吃鱼"); } public void catchMouse() { System.out.println("抓老鼠"); } } class Dog extends Animal { public void eat() { System.out.println("吃骨头"); } public void kanJia() { System.out.println("看家"); } } class DuoTaiDemo { public static void main(String[] args) { function(new Cat());//匿名对象作为参数进行传递 function(new Dog()); } public static void function(Animal a)//引用类型的提升 { a.eat(); if (a instanceof Cat)//判断Cat类是否包含在Animal类中 { Cat c = (Cat)a; c.catchMouse(); }else if (a instanceof Dog) { Dog d = (Dog)a; d.kanJia(); } } }
2.3内部类
定义:将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
访问特点:
内部类可以直接访问外部类中的成员,包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
为什么内部类可以直接访问外部类中的成员呢?
那是因为内部中都持有一个外部类的引用。这个引用是 外部类名.this.
内部类的特点:
内部类定义在成员位置上
可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量,但必须是被final修饰的。
外部类访问内部类方式:
1,当内部类定义在外部类成员位置上,而且非私有。在外部类其他类中,可以直接建立内部类对象。
格式:
外部类名.内部类名 变量名 = 外部对象.内部对象;
Outer.Inner in = new Ouert().new Inner();//这种方法很少用
2,当内部类出现在成员位置上就可以被成员修饰符所修饰
例如:private:将内部类在外部类中进行封装;
static:内部类就具备static的特性
当内部类被static修饰后,只能直接访问外部类中的static成员,访问受到了限制
在外部其他类中,如何直接访问static内部类的非静态成员的呢?
new Outer.Inner().function();
如何直接访问staitc内部类的静态成员呢?
Outer.Inner.funtion();
当外部类中的静态方法访问内部类时,内部类必须是静态的
当内部类中定义了静态成员,该内部类必须是静态的
代码示例:
/** 内部类 */ class Outer { int num = 0; class Inner { void show() { System.out.println("num:"+num);//内部类可以访问外部类中的成员,包括私有成员 } } public void method() { Inner i = new Inner();//外部类要访问内部类要建立内部类的对象 i.show(); } } class InnerClass { public static void main(String[] args) { Outer ou = new Outer(); ou.method(); } }
2.4 匿名内部类
匿名内部类就是内部类的简化写法。
前提:
内部类可以继承或实现一个外部类或者接口。
格式为:
new 外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
简单理解:
就是建立一个带内容的外部类或者接口的子类匿名对象。
代码示例:
/** 匿名内部类 */ abstract class A { abstract void show(); } class Outer { int num = 3; public void function() { //匿名子类对象 new A() { void show()//匿名内部类中的方法 { System.out.println("num="+num); } }.show(); } } class NoNameClass { public static void main(String[] args) { Outer ou = new Outer(); ou.function(); } }
Object类中的equals()方法和toString()方法
equals():用于比较两个对象是否相等,实际上是比较两个对象的引用类型变量中存储的地址值是否相等
根据对象的属性不同,判断对象是否相同的具体内容也不一样。所以在定义类时,一般都会复写equals方法。
toString():Object类提供的toString方法总是返回该对象实现类的“类名+@+hashCode”值,这个返回值并不能真正实现“自我描述”的功能,因此如果用户需要自定义类能实现“自我描述”的功能,就必须重写Object类的toString方法。
equals()和“==”的区别
equals():是方法,用来比较对象的内存地址值,是引用型变量间的比较
== :是运算符,可用于基本数据类型间比较,比较的是数值
也可用于引用数据类型的比较,比较的是内存地址值
代码示例:
class Students//单例设计模式,定义一个类 { private int age; private Students(){}; private static Students s = new Students(); public static Students show() { return s; } } class EqualsDemo { public static void main(String[] args) { //分别建立对象s1,s2 Students s1 = Students.show(); Students s2 = Students.show(); boolean a = s1.equals(s2);//判断两个对象是否相等 System.out.println(a);//返回值是true } }
toString():Object类提供的toString方法总是返回该对象实现类的“类名+@+hashCode”值,这个返回值并不能真正实现“自我描述”的功能,因此如果用户需要自定义类能实现“自我描述”的功能,就必须重写Object类的toString方法。
代码示例:
/** toString 思路: 定义一个类Student 显示初始化name和age变量 修改类中的name 输出修改后的对象 */ class Student { String name; int age; Student(String name,int age) { System.out.println("name:"+name+"...age:"+age); } public String toString() { return "name:"+name+"...age:"+age; } } class ToStringDemo { public static void main(String[] args) { Student s = new Student("zhangsan",22); s.name = "lisi"; System.out.println(s.toString()); } }
3. 包(package)
3.1 包的概述
对类文件进行分类管理。
给类提供多层命名空间。
写在程序文件的第一行。
类名的全称的是 包名.类名。
包也是一种封装形式。
3.2 包之间的访问
被访问的包中的类权限必须是public的。
类中的成员权限:public或者protected
protected是为其他包中的子类提供的一种权限
3.3 四种权限
3.4 import
简化类名。
一个程序文件中只有一个package,可以有多个import。
用来导包中的类,不导入包中的包。
3.5 jar包
jar包的概述:
Java的压缩包
方便项目的携带。
方便于使用,只要在classpath设置jar路径即可。
3.6 jar包的操作
通过jar.exe工具对jar的操作。
创建jar包
jar -cvf mypack.jar packa packb
查看jar包
jar -tvf mypack.jar [>定向文件]
解压缩
jar -xvf mypack.jar
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
相关文章推荐
- C++中的static用法(面向过程+面向对象)
- Python基础(11)--面向对象1
- PHP学习笔记之继承(面向对象三大特性之一)
- JAVA-OOP(面向对象)
- JavaScript面向对象之属性实现javascript
- java基础面向对象继承和多态
- Python面向对象
- Java学习3:面向对象
- java 面向对象
- java面向对象(十一) 覆写
- 4.3 从面向过程到面向对象
- 面向对象的第二个特征----继承I(单继承与多重继承)
- java 基础---面向对象(继承)
- Java面向对象的解析
- OC面向对象及继承
- 面向对象的第二个特征----继承III(子父类中成员的特点与覆盖)
- 模仿go语言的C语言面向对象范式
- Oracle笔记 十二、PL/SQL 面向对象oop编程
- js面向对象的学习
- 3.面向对象的核心