黑马程序员_面向对象02

----------------------Android培训、Java培训、java学习型技术博客、期待与您交流！ ----------------------

/*
继承：
1、提高了代码的复用性。
2、使类与类之间产生了关系。有了这个关系才有了多态的特性。
注：java语言中只支持单继承而不支持多继承，因为多继承容易发生安全隐患。
 但java支持多层继承。
 例如：
 class A
 {
  public void show()
  {
   System.out.println("A");
  }
 }
 class B
 {
  public void show()
  {
   System.out.println("B");
  }
 }
 class C extends A,B
 {}
 C类定义了A类、B类，当建立C类对象调用show()方法时，不知道该调用哪一个。

*/
/*
子父类之间的变量、函数、构造函数
一、变量
 当子类中定义的变量与父类非私有的变量同名时，子类访问本身的变量用this，子类访问父类的变量用super。
 this代表本类对象的引用，super代表父类对象的引用。
二、函数
 当子类定义了与父类一样的函数时，子类对象在调用该方法时只运行子类函数的内容。
 这种现象是函数的另一个特性：重写。
三、构造函数
 因为父类中的数据子类可以直接获得所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
 所以在子类对象初始化时，要先访问父类的构造函数。
 因为子类的构造函数默认的第一行隐式的语句是 super(),super()语句会访问父类中空参数的构造函数
 如果想访问父类中指定的构造函数，可以手动的定义super语句来实现。
 super语句一定定义在子类构造函数的第一行。
*/

/*
复写(覆盖)：子父类方法要一模一样，但是内容不同。
子类继承父类，沿袭父类的功能到子类中，但是子类功能的内容和父类的不一致，这是吗、子类中没有必要在定义新的功能，
而是使用覆盖特性，保留父类的功能丁定义，并重写功能内容即可。
注意:
 1、子类再覆盖父类方法时，必须保证子类的权限大于或等于父类的方法权限，这样才可以覆盖，否则会编译失败。
 2、静态只能覆盖静态。
*/

class JiCheng
{
 public static void main(String[] args)
 {
  //通过调用空参数的构造函数创建Student1对象
  new Student1();
  //通过调用带参数的构造函数创建Student1对象
  Student1 stu = new Student1("lxh",24,100);
  stu.sayMe();
 }
}
//创建Person1类
class Person1
{
 //定义成员变量，并私有化。
 private String name;
 private int age;
 //空参数的构造函数。
 Person1()
 {
  System.out.println("Person");
 }
 //带参数的构造函数，创建对象并对变量初始化。
 Person1(String name,int age)
 {
  this.name = name;
  this.age = age;
  System.out.println("Hello Person");
 }
 //设置对象姓名
 public void setName(String name)
 {
  this.name = name;
 }
 //设置对象年龄。
 public void setAge(int age)
 {
  this.age = age;
 }
 //获取对象姓名。
 public String getName()
 {
  return this.name;
 }
 //获取对象的年龄。
 public int getAge()
 {
  return this.age;
 }
 //成员方法。
 public void sayMe()
 {
  System.out.println("姓名："+getName()+" 年龄："+getAge());
 }
}
//创建Student1类，并继承Person1类。
class Student1 extends Person1
{
 //定义成员变量，并私有化。
 private int score;
 //空参数的构造函数
 Student1()
 {
  //super();
  System.out.println("Student");
 }
 //带参数的构造函数，创建对象并对变量初始化。
 Student1(String name,int age,int score)
 {
  //调用父类的带对应参数的构造函数。
  super(name,age);
  this.score = score;
  System.out.println("Hello Student");
 }
 //设置对象的成绩。
 public void setScore(int score)
 {
  this.score = score;
 }
 //获取对象的成绩。
 public int getScore()
 {
  return this.score;
 }
 //重写父类的成员方法。
 public void sayMe()
 {
  System.out.println("姓名："+getName()+" 年龄："+getAge()+"  成绩："+getScore());
 }
}

/*
运行结果：
Person
Student
Hello Person
Hello Student
姓名：lxh 年龄：24 成绩：100
*/

/*
抽象类：
特点：
 1、抽象方法一定在抽象类中。
 2、抽象方法和抽象类都必须被abstract关键字修饰。
 3、抽象类不可以用new创建对象，因为调用抽象方法无意义。
 4、抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。
注：抽象类中可以不定义抽象方法，这样做仅仅是不让类建立对象。
 抽象类在被继承后，子类必须覆盖父抽象类中的所有抽象方法，不然子类也必须用abstract修饰，成为抽象类。
*/
abstract class A
{
 abstract void show();
}
class B extends A
{
 public void show()
 {
  System.out.println("show");
 }
}
class AbstractClassDemo
{
 public static void main(String[] args)
 {
  B b = new B();
  b.show();
 }
}

/*
接口：
 interface 用于定义接口
接口定义时格式特点：
 1、接口中常见定义：常量、抽象方法。
 2、接口中成员都有固定的修饰符
  常量：public static final
  方法：public abstract
 注：接口中是我成员都是public的。
注：接口不可以创建对象，因为有抽样方法。需要被子类实现，子类的接口中的抽样方法全面覆盖后子类才可以实例化。
 否则子类是一个抽象类。
*/
interface Inter
{
 public static final int NUM = 1;
 public abstract void show();
}
class InterDemo implements Inter
{
 public void show()
 {
  System.out.println("show..."+NUM);
 }
}

class InterfaceDemo
{
 public static void main(String[] args)
 {
  InterDemo id = new InterDemo();
  id.show();
 }
}

/*
多态：事物存在的多种形态。
多态的体现：
 父类的引用指向了子类对象。
 父类的引用也可以接受子类的对象。
多态的前提：
 必须使类与类之间，要么继承，要么实现。
多态的好处；
 多态的出现大大提高了程序的扩展性。
多态的弊端
 只能使用父类引用访问父类中的成员。
多态的应用：
*/
abstract class Animal
{
 public abstract void jiao();
}
class Dog extends Animal
{
 public void jiao()
 {
  System.out.println("汪汪汪");
 }
 public void kanJia()
 {
  System.out.println("看家");
 }
}
class Cat extends Animal
{
 public void jiao()
 {
  System.out.println("喵喵喵");
 }
 public void zhuaLaoShu()
 {
  System.out.println("抓老鼠");
 }
}
class DuoTaiDemo
{
 public static void main(String[] args)
 {
  //父类的引用指向子类对象
  //类型提升，向上转型。
  Animal a = new Dog();
  a.jiao();
  //强制将父类的引用转换成子类类型。向下转型
  Dog dog = (Dog)a;
  dog.kanJia();
  function(new Cat()); //Animal a = new Cat()
 }
 public static void function(Animal a)
 {
  a.jiao();
 }
}
/*
z在多态中成员函数的特点：
 在编译时期，参阅的是引用型变量所属的的类中是否有调用的方法。如果有，编译通过，如果没有则编译失败
 在运行时期，参阅的是对象所属类中是否有调用额方法
 总结：编译时看左边，运行时看右边。
多态中成员变量的特点：
 无论是编译还是运行都参阅引用型变量所属的类，即看左边
多态中静态成员函数的特点：
 无论是编译还是运行都参阅引用型变量所属的类，即看左边
*/
class A
{
 int num = 7;
 public void show1()
 {
  System.out.println("A...show1");
 }
 public void show2()
 {
  System.out.println("A...show2");
 }
 public static void show4()
 {
  System.out.println("A...show4");
 }
}
class B extends A
{
 int num = 8;
 public void show1()
 {
  System.out.println("B...show1");
 }
 public void show3()
 {
  System.out.println("B...show3");
 }
 public static void show4()
 {
  System.out.println("B...show4");
 }
}
class DuoTaiDemo2
{
 public static void main(String[] args)
 {
  A a = new B();
  a.show1();
  a.show2();
  //a.show3();
  a.show4();
  System.out.println(a.num);
 }
}
/*
编译时会出现错误：
DuoTaiDemo2.java:50: 错误: 找不到符号
                a.show3();
                 ^
  符号:   方法 show3()
  位置: 类型为A的变量 a
  因为在编译时看引用型对象所属的类，而上面的代码在A类中没有show3()方法，所以编译失败。
  当注释掉a.show()这条语句是，就可以编译通过。
执行的结果是：B...show1  A...show2  A...show4  7
  */

/*
内部类：将一个类定义在另一个类的里面，里面那个类就成为内部类。
访问特点：
 1、内部类可以直接访问外部类中的成员，包括私有。
 2、外部类必须创建内部类的对才可以访问内部类中的成员。
访问格式：
 1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象。
 格式：
  外部类名.内部类名 变量名 = 内部类对象。外部类对象
  Outer.Inner in = new Outer().new Inner();
 2、内部类定义在成员位置上时可以被成员修饰符修饰。
  比如：private ：将内部类在外部类中进行封装
   static ：内部类具备static的特性。
   在外部其他类中直接访问静态内部类中的非静态成员：
    new 外部类名.内部类名().方法名()
   在外部其他类中直接访问静态内部类中的静态成员：
    外部类名.内部类名.方法名()
  注：当内部类中定义了静态成员时，该类也应该是static的
 3、内部类定义在局部时：
  不可以被修饰符所修饰。
  可以访问外部类中的成员。但不可以访问所在局部中的变量，只能访问被final修饰的局部变量。

匿名内部类：
 定义匿名内部类的前提：
  内部类必须是继承了一个类或是实现接口。
 匿名内部类的格式：
  new 父类或者接口(){定义子类的内容}
*/
class Outer
{
 //在外部类中定义私有变量
 private int x = 7;
 //定义成员位置上的非静态内部类
 class Inner1
 {
  //在内部类中定义方法访问外部类中的私有变量
  public void inner1()
  {
   System.out.println("inner1..."+x);
  }
  public void show1()
  {
   System.out.println("show1");
  }
 }
 //定义一个静态内部类
 static class Inner2
 {
  //定义内部类中的静态方法
  public static void inner2()
  {
   System.out.println("inner2");
  }
  //内部类中的非静态方法
  public void show2()
  {
   System.out.println("show2");
  }
 }
 //外部类方法
 public void show(final int y)
 {
  //定义局部位置上的内部类，定义方法访问外部类私有变量和被final修饰的局部变量
  class Inner3
  {
   void inner3()
   {
    System.out.println("inner3..."+x+"...."+y);
   }
  }
  new Inner3().inner3();
 }
 public void run()
 {
  //通过建立内部类对象调用内部类的方法
  Inner1 in1 = new Inner1();
  in1.show1();
 }
}
//创建一个ZiOuter类继承Outer类
class ZiOuter extends Outer
{
 public void run()
 {
  System.out.println("匿名内部类");
 }
}

class NeiBuLeiDemo
{
 public static void main(String[] args)
 {
  //建立外部类对象调用外部类中的方法
  Outer out = new Outer();
  out.run();
  out.show(5);
  //直接建立内部类的对象调用内部类的方法
  Outer.Inner1 in = new Outer().new Inner1();
  in.inner1();
  //直接访问静态内部类中的非静态成员
  new Outer.Inner2().show2();
  //直接访问静态内部类中的静态成员：
  Outer.Inner2.inner2();
  //用匿名内部类形式实现Outer子类ZiOuter
  new Outer(){
   public void run()
   {
    System.out.println("匿名内部类");
   }
  }.run();

 }
}
/*
运行结果：
show1
inner3...7....5
inner1...7
show2
inner2
匿名内部类
*/

----------------------Android培训、Java培训、java学习型技术博客、期待与您交流！ ----------------------