星期二, 十一月 10, 2015 10:34:07
?
?
封装
?
继承
? 可以从一个简单的类继承出相对复杂高级的类
?
多态
? ? ? 可以动态的对对象进行调用，使对象之间变得相对独立。
?
?
一:类的封装性
?
1.看下面的案例、
?
?----1.1代码案例:
package day09;
?
public class CapsulationTest {
public static void main(String[] args) {
Person p = new Person();
p.age = -23;
p.name = "宇宙歆儿";
p.talk();
}
}
?
class Person {
String name;
int age;
Person() {
}
?
public void talk() {
System.out.print("我的名字叫:"+name+"\n"+"年龄:"+age);
}
}
?
运行结果:
我的名字叫:宇宙歆儿
年龄:-23
?
?
注意:
加工的原料有问题，生产出来的也有问题。
而导致这种错误的原因是，就是因为程序在原料的入口没有校验。
?
?
----1.2.类的封装实例
?
? ? ? ? 之前所列举的程序都是用对象直接访问类中的属性，这在面向对象法则中是不允许的。
所以为了避免程序中这种错误的发生，在一般的的开发中往往要将类中的属性封装(private)。
?
代码案例:
package day09;
?
public class CapsulationTest {
public static void main(String[] args) {
Person p = new Person();
p.age = -23;
p.name = "宇宙歆儿";
p.talk();
}
}
?
class Person {
private String name;//设置为private
private int age;//设置为private
Person() {
}
?
public void talk() {
System.out.print("我的名字叫:"+name+"\n"+"年龄:"+age);
}
}
?
结果:
p.age = -23;
p.name = "宇宙歆儿";
?
直接对对象的属性进行访问，出现报错。是因为设置的属性为private，不可以直接对其进行访问。
?
注意:
? ? ?为私有的，不可以直接访问，这样就可以保证对象无法直接去访问类中的属性。
?
但是如果非要给对象赋值的话，解决方法是:
? ? 会增加一些方法，如 setXxx()、 getXxx()这样的公用方法来解决这一矛盾。
?
----1.3自己总结：
?
1.通过set方法进行将privat的值改变
? 改变完了还是private的修饰符
?
2.要使用get方法取出私有属性的值
? 然后转换为外部可访问的值。
?
?
----1.4代码案例:
package day09;
?
public class CapsulationTest {
public static void main(String[] args) {
Person p = new Person();
p.setName("宇宙歆儿");
p.setAge(3);
/*p.getAge();
p.getName();*/
p.talk();//这个不用调用get是因为talk()已经可以访问了
}
}
?
/*setXxx()、 getXxx()为了解决:
? ? 但是如果非要给对象赋值的话，解决方法是:
? ? 会增加一些方法，如 setXxx()、 getXxx()这样的公用方法来解决这一矛盾。*/
class Person {
private String name;
private int age;
Person() {
}
?
public void talk() {
System.out.print("我的名字叫:"+name+"\n"+"年龄:"+age);
}
?
public void setName(String name) {
? ?this.name = name;
}
?
public void setAge(int a) {
if (a > 0) {
this.age = a;
}
}
?
public String getName() {
return name;
}
?
public int getAge () {
return age;
}
}
运行结果:
我的名字叫:宇宙歆儿
年龄:3
?
在set中设置了判断合理性
，设置age = -23
?
运行结果:
我的名字叫:宇宙歆儿
年龄:0
age为默认值0，可以保证数据的安全性。
?
?
注意:
?
? ? 关于封装与否并没有明确的规定，不过从程序设计的角度来说，一般来说设计较好的程序的类中的属性都是需要封装的。
?
此时则只能使用setXxx()、getXxx()方法，这是一个明确的标准的规定。
?
?
将属性进行私有化
?
----1.5封装的优点：
?
? ?（1）隐藏类的实现细节；
? ?（2）让使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
? ?（3）便于修改，增强代码的可维护性；
?
?
?
二.类的继承
?
? 类的继承可以以既有类为基础，进而派生出新的类。
通过这种方式，便能快速地开发出新的类，
而不是编写相同的程序代码，这就是程序代码再利用的概念。
?
----2.1继承的基本概念
?
?
在Java中，通过继承可以简化类的定义，扩展类的功能。
在Java中支持类单继承和多继承，但是不支持多继承，
即一个类只能继承一个类而不能继承多个类。
?
继承的格式:
? ? class 子类名 extends 父类
?
?
?
Java继承
-----只能直接继承父类中的公有属性和公有方法，
而隐含地(不可见地)继承了私有属性。
?
----2.2类的继承的实例
?
代码案例:
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s1 = new Student();
? ?s1.setName("瓦询");
? ?s1.setAge(24);
? ?s1.setSchool("丰趣海淘");
? ?System.out.println(s1.getName()+"\n"+s1.getAge()+"\n"+s1.getSchool());
}
}
?
class Person{
private String name ;
private int ? ?age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
?
class Student extends Person {
private String school;
?
public void setSchool(String school) {
this.school = school;
}
?
public String getSchool() {
return school;
}
}
?
?
运行结果:
瓦询
24
丰趣海淘
?
注意:
? ? 在Java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类。
但是Java中却允许多层继承。A<--B<--C
?
?
?
----2.3.类的继承专题研究
?
关于继承的问题，有一些概念和过程需要澄清，有些语法和术语需要熟练掌握。本节做一些总结。
?
2.3.1子类对象的实例化过程
?
结论:
? ? 子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应的构造方法。
?
代码案例:
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s1 = new Student();
}
}
?
class Person{
String name ;
int ? ?age;
public Person() {
System.out.print("public Person()"+"\n");
}
}
?
class Student extends Person {
String school;
public Student() {
/*super();*/
System.out.print("public Student()");
}
}
?
运行结果:
public Person()
public Student()
?
2.3.2 super关键字
?
结论:
? ? super主要的功能时完成子类调用父类中的内容，也就是调用
父类中的属性或方法。
?
?
注意:
? ?用super调用父类中的构造方法，只能放在程序的第1行。
?
代码案例:
/*用super调用父类中的构造方法*/
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s1 = new Student();
s1.school = "海淘";
System.out.print("姓名:"+s1.name+"\n年龄: "+s1.age+"\n学校:"+s1.school);
}
}
?
class Person{
String name ;
int ? ?age;
public Person(String n,int a) {
this.name = n ;?
this.age = a;
}
}
?
class Student extends Person {
String school;
public Student() {
super("宇宙歆儿7",25);
}
}
?
运行结果:
姓名:宇宙歆儿7
年龄: 25
学校:海淘
?
super关键字不仅可用于调用父类中的构造方法，也可用于调用父类中的属性和方法。
?
格式:
? ?super.父类中的属性；
? ?super.父类中的方法()
?
2.3.3通过super调用父类的属性和方法
?
代码案例:
?
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s1 = new Student("刘惜君",28,"恋风恋歌");
System.out.print(s1.school);
}
}
?
class Person{
String name ;
int ? ?age;
public Person() {
}
?
public String talk() {
return "...名称:"+name+"\n年龄:"+age;
}
?
}
/*通过super调用父类的属性和方法*/
class Student extends Person {
?
String school;
public Student(String name,int age,String school) {
super.name = name;//在这里使用super进行调用父类的属性
super.age = age;
System.out.println(super.talk());//调用父类中的方法
this.school = school;//调用本类中的属性
} ? ?
}
?
运行结果:
...名称:刘惜君
年龄:28
恋风恋歌
?
本例中，super换成this也是可以的，那为什么还要用super呢?
----见下例
?
2.3.4.限制子类的访问
?
? 有些时候，父类并不希望子类可以访问自己的类中全部的属性和方法，所以需要将一些属性与方法隐藏起来，不让子类去使用。
为此可在声明属性或方法时加上“private”关键字，表示私有。
?
代码案例:
?
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s = new Student();
s.setVar();
System.out.println("名称:"+s.getName()+"\n"+s.getAge());
}
}
?
class Person{
private String name ;
private int ? ?age;
?
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
?
class Student extends Person {
public void setVar() {
super.setName("宇宙");
super.setAge(1111);
}
}
?
运行结果:
名称:宇宙
年龄:1111
?
2.3.5最后注意 super 与 this 的区别：
?
? ? ? ? super 不是一个对象的引用，
? ? ? ?不能将 super 赋值给另一个对象变量，
? ? ? 它只是一个指示编译器调用父类方法的特殊关键字。
?
super 关键字的功能：
调用父类中声明为 private 的变量。
点取已经覆盖了的方法。
作为方法名表示父类构造方法。
?
2.3.6代码案例:
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s = new Student();
s.setVar();
}
}
?
class Person{
private String name = "jami soul she";
?
public String getName() {
return name;
}
}
?
class Student extends Person {
public void setVar() {
// 通过 getter 方法调用父类隐藏变量
? ? ?System.out.println(super.getName());
}
}
?
运行结果:
jami soul she
?
?
----4.覆盖
?
在程序中可以看到，在子类中可以通过super.方法()调用父类中被子类覆盖的方法。
?
代码案例:
/*验证在遇到方法的覆盖时，可以使用super调用父类的方法 */
package day09;
?
public class InheritTest {
public static void main(String[] args) {
Student s = new Student("五月天",32,"五迷五迷");
System.out.print(s.talk1());
}
}
?
class Person{
String name ;
int age;
public String talk1() {
return "姓名="+name+"\n年龄="+age;
}
}
?
class Student extends Person {
String school;
?
public Student(String name,int age,String sc){
this.name = name;
this.age = age;
this.school = sc;
}
public String talk1() {
/*不加这个的话，父类的talk1()方法不会被执行，因子类已经进行了方法的覆盖*/
return super.talk1()+"\n公司="+school;
}
}
?
运行结果:
姓名=五月天
年龄=32
公司=五迷五迷
?
?
三.类的多态
?
最重要的一个特性---多态
?
----3.1 多态的基本概念
?
重载的最终效果是调用同一个方法名称，却可以根据传入的参数不同的处理结果，这其实就是多态的一种体现。
?
?
代码案例:
package day09;
?
public class PolymorphismTest {
public static void main(String[] args) {
?
/*父类的对象通过子类进行的实例化，
* 所以在调用fun1（时，
* 调用的是子类的次方法*/
Person p = new Student();
p.fun1();
p.fun2();
}
}
?
class Person {
public void fun1() {
System.out.println("1.fun1()");
}
public void fun2() {
System.out.println("2.fun2()");
}
}
?
class Student extends Person{
//进行覆盖父类的fun1()方法
public void fun1() {
System.out.println("3.fun1()");
}
public void fun4() {
System.out.println("4.fun4()");
}
}
运行结果:
3.fun1()
2.fun2()
?
?
? ? ? 案例的原因是因为父类对象并非由其本身的类实例化，而是通过子类实例化
这就是所谓的对象的多态性，即子类实例化对象可以转换为父类实例化对象
?
星期二, 十一月 10, 2015 19:22:18 ? Java从入门到精通P182
?
----3.2 类的多态实例
?
在这里要讲解两个概念，予以重视。
?
3.2.1向上转型
?
向上转型
在上个例子中，父类对象通过子类对象去实例化，实际上就是对对象的向上转型。
向上转型是不需要进行强制类型转换的，但是向上转型会丢失精度。
?
向下转型
就是父类的对象可以转换为子类对象，但是需要注意的是，
这时则必须要进行强制的类型转换。
?
总结:
?
1.向上转型可以自动完成
2.向下转型必须进行强制类型转换
?
注意:
?
?
并非全部的父类对象都可以强制转换为子类对象。
代码案例:
package day09;
?
public class PolymorphismTest {
public static void main(String[] args) {
?
/*父类的对象通过子类进行的实例化，
* 所以在调用fun1（时，
* 调用的是子类的次方法*/
?
/*Person p = new Person();
将p向下转型:
* 父类用其本身类实例化自己的对象，
* 但它并不知道谁是自己的子类，
* 那肯定在转换时会出现错误。
* Exception in thread "main" java.lang.ClassCastException:
* ?day09.Person cannot be cast to day09.Student
at day09.PolymorphismTest.main(PolymorphismTest.java:11)
Student p2 = (Student)p;
*/
?
Person p = new Student();//p为person的子
Student p2 = (Student)p;
p2.fun1();
p2.fun2();
?
?
?
}
}
?
class Person {
public void fun1() {
System.out.println("1.fun1()");
}
public void fun2() {
System.out.println("2.fun2()");
}
}
?
class Student extends Person{
//进行覆盖父类的fun1()方法
public void fun1() {
System.out.println("3.fun1()");
}
public void fun3() {
System.out.println("4.fun3()");
}
}
?
运行结果:
3.fun1()
2.fun2()
?
问题总结:
?
? ?父类用其本身类实例化自己的对象，但它并不知道谁是自己的子类，那肯定在转换时
会出现错误。
?
修改方法:
? 将实例化代码改为Person p = new Studengt();
这样就是由子类去实例化父类对象，
也就是说这个时候父类知道有这么一个子类，也就是相当于父亲知道自己有这么一个孩子。
所以下面再进行转换时就不会再有问题。
?
星期二, 十一月 10, 2015 20:08:41
?
?
?
原文：http://yuzhouxiner.iteye.com/blog/2256062