疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java面向对象部分学习总结


 

   

  对象:是具体的事物,我们叫做object,instance实例,以后我们说某个类的对象,某个类的实例,是一样的意思

  类:是对对象的抽象,我们叫做class,是对现实生活中事物的描述。

  类和对象的关系:特殊到一般,具体到抽象。

  类可以看成一类对象的模板,对象可以看成该类的一个具体实例。

  类是用于描述同一类型的对象的一个抽象的概念,类中定义了这一类对象所应具有的静态和动态属性。

  成员变量和局部变量

  1、局部变量

  定义在方法内或者语句块内 从属于方法或者语句块

  使用之前,必须手动初始化。

  2、成员变量

  定义在类里面、方法外面。从属于对象

  如果没有手动初始化成员变量,系统会自动初始化。初始化的规则如下:

  数字:0,0.0 布尔 false char u0000 引用类型 :null。

  匿名对象的应用

  匿名对象时对象的简化形式;

  new 实例名称();

  使用方式一:当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化,如果对一个对象进行多个成员调用,必须给这个对象起个名字。

  使用方式二:可以将匿名对象作为参数使用。

  面向对象三大特征: 封装 继承 多态

  继承:

  1.提高了代码的复用性

  2.让类与类之间产生了关系,有了这个关系,才有了多态的特性。必须是类与类之间有所属关系才可以使用继承。所属关系 is a。

  java只支持单继承,不支持多继承,多继承容易带来安全隐患:当多个父类中定义了多个相同功能,当功能内容不相同时,不确定调用了父类的哪一个。

  但是java可以通过多实现来实现。

  Java同时支持多层继承。

  先要使用集成体系,先要查阅父类的功能,因为父类中定义的是该体系中的共性功能,通过了解共性功能,就知道该体系的基本功能。

  调用时要创建最子类的对象,原因是:

  1.因为有可能父类不能创建对象

  2.创建子类对象可以使用更多功能,包括基本的也包括特有的。

  子父类出现后类成员的特点:

  1.子父类中变量的特点:

  父类的成员变量私有化之后,子类依然继承,但不能直接访问。

  如果子类中出现非私有的同名成员变量时,自雷要访问本类中的变量用 this ,要访问父类中的同名变量,用super,

  super的使用和this的使用 几乎一致。

  this:本类对象的引用

  super:父类对象的引用。一定要放在子类函数的第一行。

  2.子父类中函数的特点:–覆盖(override)

  当子类中出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容,如同父类的函数被覆盖一样。这就是重写。

  当子类继承了父类,沿袭了父类的功能,到子类中,但是子类虽然具备该功能,但是功能的内容却和父类不一样,这是没有必要定义新

  功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。这是用 super。

  注意:

  1).子类覆盖父类,必须保证子类权限大于等于父类权限,才能重写

  2).静态只能访问静态

  重载和重写:

  重载:只看同名函数的参数列表

  重写:字符类方法要一模一样。

  3.子父类中构造函数的特点:

  在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数。子类只会隐式调用父类的空参构造函数。

  子类一定要访问父类中的构造函数:

  因为父类中的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。

  注意:super语句一定定义在子类构造函数的第一行。

  子类的所有构造函数,默认都会访问父类中孔参数的构造函数,因为子类的每一个构造函数内的第一行都有一句隐式super();

  当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。

  当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少会有一个构造函数会访问父类中的构造函数。

  继承:

  1.提高了代码的复用性

  2.让类与类之间产生了关系,有了这个关系,才有了多态的特性。必须是类与类之间有所属关系才可以使用继承。所属关系 is a。

  java只支持单继承,不支持多继承,多继承容易带来安全隐患:当多个父类中定义了多个相同功能,当功能内容不相同时,不确定调用了父类的哪一个。

  但是java可以通过多实现来实现。

  Java同时支持多层继承。

  先要使用集成体系,先要查阅父类的功能,因为父类中定义的是该体系中的共性功能,通过了解共性功能,就知道该体系的基本功能。

  调用时要创建最子类的对象,原因是:

  1.因为有可能父类不能创建对象

  2.创建子类对象可以使用更多功能,包括基本的也包括特有的。

  子父类出现后类成员的特点:

  1.子父类中变量的特点:

  父类的成员变量私有化之后,子类依然继承,但不能直接访问。

  如果子类中出现非私有的同名成员变量时,自雷要访问本类中的变量用 this ,要访问父类中的同名变量,用super,

  super的使用和this的使用 几乎一致。

  this:本类对象的引用

  super:父类对象的引用。一定要放在子类函数的第一行。

  2.子父类中函数的特点:–覆盖(override)

  当子类中出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容,如同父类的函数被覆盖一样。这就是重写。

  当子类继承了父类,沿袭了父类的功能,到子类中,但是子类虽然具备该功能,但是功能的内容却和父类不一样,这是没有必要定义新

  功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。这是用 super。

  注意:

  1).子类覆盖父类,必须保证子类权限大于等于父类权限,才能重写

  2).静态只能访问静态

  重载和重写:

  重载:只看同名函数的参数列表

  重写:字符类方法要一模一样。

  3.子父类中构造函数的特点:

  在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数。子类只会隐式调用父类的空参构造函数。

  子类一定要访问父类中的构造函数:

  因为父类中的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。

  注意:super语句一定定义在子类构造函数的第一行。

  子类的所有构造函数,默认都会访问父类中孔参数的构造函数,因为子类的每一个构造函数内的第一行都有一句隐式super();

  当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。

  当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少会有一个构造函数会访问父类中的构造函数。

  多态

  :可以理解为事物存在的多种体现形态。

  父类的引用指向子类的对象。

  1.多态的体现

  父类的引用指向子类的对象,父类的引用接收子类的对象。

  2.多态的前提

  类与类之间必须是继承或者实现的关系。通常还有一个前提 就是覆盖

  3.多态的好处

  大大的提高了程序的扩展性

  4.多态的弊端

  提高了扩展性,但是只能使用父类的引用访问父类中的成员。

  5.多态的应用

  6.多态中成员的特点

  a)非静态成员函数:在编译时期,参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。

  在运行时期,参阅对象所属的类中是否有调用的方法。

  总结,成员函数在多态调用的时候,编译看左边父类,运行看右边子类。

  b)成员变量:无论编译和运行,都参考左边父类。

  c)静态成员函数:无论编译和运行都参考左边父类。

  如何使用子类特有方法:多态转型。

  Animal a=new Cat();//类型提升,向上转型。

  a.eat();//父类的共有方法。

  如果要调用cat的特有方法的时候 ,就必须将父类的引用转成子类的类型,但是不能将父类对象转成子类类型,转换的是父类的引用,(就是父类的变量)

  Cat c=(Cat)a;

  c.catchmouse();//子类的特有方法。

  事例:

  /*

  * 基础班学生:

  * 学习 、睡觉

  * 高级班学生

  * 学习、睡觉

  *

  */

  abstract class Student {

  public abstract void study();

  public static void sleeps(){

  System.out.print("睡觉");

  }

  }

  class jichu extends Student{

  public void study()

  {

  System.out.print("学习基础");

  }

  public static void sleeps(){

  System.out.print("站着");

  }

  }

  class gaoji extends Student{

  public void study()

  {

  System.out.print("学习高级");

  }

  public static void sleeps(){

  System.out.print("趴着");

  }

  }

  class DoStudent

  {

  public void dosome(Student stu)

  {

  stu.study();

  stu.sleeps();

  }

  }

  public class duotai {

  public static void main(String[] args) {

  DoStudent ds=new DoStudent();

  ds.dosome(new jichu());//传的是子类对象

  ds.dosome(new gaoji());

  }

  }

  接口:interface,如果抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。接口定义的一组规范,

  实现现实世界中这样的逻辑 :如果你是。。。则必须能。。。

  class用于定义类,interface用于定义接口

  接口的特点:

  1.接口中常见定义:常量,抽象方法。

  2.接口中的成员都有固定修饰符

  常量 public static final

  方法 public abstract

  接口中的成员都是public的。

  接口是不可以创建对象的,因为有抽象方法,需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化,否则子类是一个抽象类。

  接口可以被类多实现。也是对。多集成不支持的转换形式,JAVA支持多实现。

  类与类之间是继承,只能单继承

  类与接口之间是实现,可以多实现

  接口与接口之间是继承,可以多继承。

  接口:借口是对外暴露的规则,借口是程序的工恩那个扩展,接口可以原来多实现,类与接口之间是实现关系,而且类的消失可以继承一个类的同时

  实现多个接口,接口与接口之间可以有继承关系。

  基本功能定义在类中,扩展功能定义在接口中。

  单例设计模式:解决一个类在内存中只有一个对象

  多个程序使用统一配置信息对象时,需要保证该对对象的唯一性。

  保证对象唯一性的实现步骤:

  1.将构造函数私有化:为了避免其他程序过多建立该对象,禁止其他程序调用该对象。

  2.在类中创建一个本类对象:为了让其他程序可以访问该类对象

  3.提供一个方法可以获取到该对象的方法:方便其他程序访问自定义的本类对象。

  //饿汉式:一进内存 就创建了对象

  class single{

  private single(){}//1.将构造函数私有化

  private static single s=new single();//2.在类中创建一个本类对象

  public static single getInstance(){//3.提供一个方法可以获取到该对象的方法

  return s;

  }

  }

  public class SingleDemo {

  public static void main(String[] args) {

  single ss=single.getInstance();

  }

  }

  //懒汉式:什么时候调用什么时候创建对象,对象的延时加载

  class single{

  private single(){}

  private static single s=null;

  public static single getInstance(){

  if(s==null){

  synchronized(Single.class)//同步锁

  {

  if (s==null){

  s=single.getInstance();

  }

  }

  }

  return s;

  }

  }

  public class SingleDemo {

  public static void main(String[] args) {

  single ss=single.getInstance()

  }

  }

  内部类

  讲一个雷定义在另一个类的里面,对立面那个类就叫做内部类,或者嵌套类。

  特点,内部类可以直接访问外部类中的成员。包括私有成员。而外部类要访问内部类中的成员必须要建立内部类对象。

  //代码

  class outer

  class inner

  void function(){}

  }

  }

  inner内部类。

  访问规则:1.内部类可以直接访问外部类中的成员,包括私有。是因为内部类中持有了一个外部类的引用。格式:外部类名.this

  2.外部类要访问内部类,必须要建立内部类的对象。

  3.内部类作为外部类的成员 可以被私有化

  如何直接访问内部类中的成员 function()

  outer.inner in=new outer().inner();

  in.function();

  访问格式:

  1.当内部类定义在外部类的位置上的时候,而且非私有,可以在外部其他类中,可以直接建立内部类对象

  格式 外部类名.内部类名 变量名=外部类对象.内部类对象

  outer.inner in=new outer().inner();

  2.当内部类在成员的位置上,就可以被成员修饰符所修饰。

  比如:private static,

  当内部类被static修饰后,只能直接访问外部类中的static成员,出现了访问局限

  在外部其他类中,如何直接访问static内部类的非静态成员?

  new Outer.Inner().sunction();

  在外部其他类中,如何直接访问staic内部类的静态成员?

  outer.inner.function();

  注意:当内部类中定义了静态成员,该内部类必须是static 的。

  当外部类中的静态方法访问内部类是,该内部类必须是静态的

  内部类定义原则:

  当描述事物中,事物的内部还有事物,该事物用内部类来描述。

  因为内部事务在使用外部事物中的内容。

  //局部内部类

  class outer{

  int x=3;

  void method()

  {

  int y=4;

  class inner{

  void function(){}

  }

  }

  }

  内部类定义在局部的时候:

  1.不可以被成员修饰符修饰

  2.可以直接访问外部类中的成员,因为还持有外部类中的引用,但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量。