javaSE:面向对象知识点

来源:互联网 发布:龙虎看盘软件下载 编辑:程序博客网 时间:2024/03/28 18:06

万物皆对象。

类:一类事物、类型。进行抽象描述。类似于一个设计图纸。

对象:对象是一个具体实例。

什么是对象?什么是类?

类是对象的抽象(描述),对象是类的具体(体现)

 

类是指一组具有相同属性和方法的对象的集合。

 

类中主要包含:属性和方法。

属性代表了对象的特性,方法代表了对象的功能。

>创建对象:

对象名的命名规则与变量相同。对象本身就是一个变量。

类名对象名 = new 类名();

Cup cup = new Cup();

 

对象调属性和方法:调用对象成员。

 

对象.属性;

对象.方法(实参);

-->属性为对象成员变量,方法为对象成员方法。

 

 

属性(成员变量)

1.声明在类中。

2.可以初始化也可以不初始化,如果没有初始化有默认值。

3.随着对象的产生而产生,随着对象的销毁而销毁。

  在堆内存中。

4.可以有访问修饰符。

 

局部变量:

1.声明在方法里。

2.必须初始化。

3.随着方法的进栈而产生,随着方法的弹栈而销毁。

  在栈内存中。

4.不可以有访问修饰符,因为方法中已经声明了。

 

当局部变量与成员变量同名的时候,调用该变量实用的是

局部变量(就近原则)

 

使用this关键字来区分局部变量和成员变量。

this:当前对象。区分局部变量和成员变量。

 

 

匿名对象:

某个对象可能只被使用一次的时候,使用匿名对象。

new 类名();

 

方法传参:

1.基本数据类型传参:

  如果把基本数据类型的变量传入方法中,相当于把该变量的

  值传入方法中,就相当于把该变量的指向常量值给copy了一下。

2.引用数据类型传参:

  如果把引用数据类型的变量传入方法中,相当于把该对象的

  内存地址传入方法中。如果对该地址中的属性进行改变,那么就

  真的改变了。

 

 

面向对象的三大特性:

封装、继承、多态。

 

封装:隐藏实现细节,对外提供公共的访问方式。

函数也是封装的一种体现。

 

访问修饰符:访问权限

           本类中   同一包中   不同包子类    任何地方

private   可以         不可以    不可以      不可以

默认       可以      可以        不可以       不可以

protected 可以     可以         可以        不可以

public    可以     可以         可以         可以

 

把属性封装

1.属性私有化 使用private修饰

2.通过方法来给属性赋值和取值  setget方法

 

类是对象的是抽象,对象是类的具体。

一个类中主要包含属性和方法。

>属性是这一类事物的特性。

>方法是该类事物的功能。

----属性:成员变量

1.定义在类中。

2.随着的对象的产生而产生,随着对象的销毁而销毁。

3.成员变量可以初始化,也可以不初始化。

  如果不初始化有默认值。因为在堆内存中。

4.可以有访问修饰符。

----局部变量:

1.定义在方法中。

2.随着方法的运行而产生,随着方法的结束而销毁。

3.局部变量必须初始化。

4.不可以有访问修饰符。

 

方法传参:

1.基本数据类型传参:相当于把该变量的常量值传入方法中,

  相当于把该常量值copy了一下,变量值不会改变。

2.引用数据类型传参:相当于把该对象的地址传入了方法中,

  如果对该地址中的对象进行改变,那么就真的改变了。

 

 

创建对象:

类名对象名 = new 类名();

调用对象成员

对象.属性

对象.方法(实参);

 

有时,某个对象只使用一次的时候使用匿名对象。

new 类名();---》匿名对象。

 

面向对象三大特性:

1.封装  2.继承  3.多态

封装:

隐藏实现细节,对外提供公共的访问方式。

封装体现在很多方面。

 

属性的封装:

1.属性私有化。

 private String name;

2.通过set get方法来对属性值进行取值和赋值。

  set方法赋值

 public void setName(String name){

         this.name= name;

  }

  get方法取值

 public String getName(){

         returnname;

  }

 

this:代表当前对象。不可以使用在静态方法(内容)中。

1>在局部变量和属性同名的时候,区分局部变量和属性。

2>调用其他构造方法的时候使用this()

 

打点调用的带括号的是方法,不带括号的是属性。

标识符后面如果带小括号,一定是方法。

 

构造方法:(构造器、构造函数)  Constructor

>>>构造方法通常用来创建对象的同时并给对象属性赋值。

 

1.所有的类都有构造方法,在没有自定义的情况下,JVM会默认

 分配一个构造器。

         publicStudent(){

                   //super();

         }

2.构造方法是一个特殊的方法,方法名与类名同名。包括了

  大小写。

3. 构造方法没有返回值类型。

   问:构造方法的返回值类似是void

   答:错!!构造方法没有返回值类型。

4.构造方法在创建对象的时候调用。使用new来调用方法。

  调用该方法创建对象。

5.构造方法可以重载。

6.在自定义构造方法之后,jvm将不会再分配给一个默认的

  构造方法,但是通常创建对象都使用无参构造,所以写

  构造方法的时候都会写一个无参构造。避免出错。

7.构造方法中可以调用普通方法。普通方法中不可以直接

  调用构造方法,必须通过new来调用,创建对象。

8.构造方法中可以有return但只能作为结束方法。(通常不用)

9.构造方法之间可以互相调用。this(实参)。只是调用其他构造

  方法的方法体(注意,不是创建对象)。只能在第一句。所以

  只能调用一个其他构造方法。

  在构造方法调用的时候,需要注意不可以相互调用(递归构造器)

 

static:静态的。主要用来修饰成员属性和成员方法。

1.static修饰的内容存在于方法区中的静态域(共享区)中。

2.方法区主要工作是加载。被static修饰的内容,静态内容

  都是随着类的加载(javac)而加载,随着类的销毁而销毁。

  JVM关闭的时候,方法区就不存在了,类销毁了,静态内容也

  随着类而销毁了。声明周期最长。

3.静态内容早于对象的出现。

4.被所有的对象共享。

5.调用静态内容:通常使用类名去调用。

  对象.静态属性 对象.静态方法 ---->静态内容被所有对象共享。

  类名.静态属性 类名.静态方法 ---->因为静态随着类的加载而加载

6.静态方法无法直接访问非静态内容。

 this不可以使用在静态方法中!!!

  因为静态内容出现的时候对象没有出现,this代表

  当前对象,所以不可以在静态方法中引用非静态内容。

7.静态内容可以直接方法静态内容。

 

---》方法的调用:

1.普通方法中直接可以调用静态内容。

2.普通方法中可以直接调用对象成员。

3.静态方法中不可以直接引用非静态内容。需要创建对象。

 

何时使用static

1.静态变量:当某个属性值被所有对象共享到时候,使用

  静态变量。

2.静态方法:当某个方法只是为了执行该方法的方法体。

  使用静态方法,不用创建对象去调用,节省了内存空间。

 

工具类:

  私有化构造方法。所有的属性都是static,所有的方法都为

 static

 

代码块:

1.普通代码块

  方法代码块:

  写在方法中。

2.构造代码块:

  在调用构造方法的时候执行。

  调用构造器---->构造代码块---->构造器

  每调用一次构造方法,构造代码块中的内容执行一次。

  相当于把构造代码块中的内容写在了构造器中的第一句。

 

  何时使用?

  在创建对象之前都会执行的内容可以放在构造代码块中,

  对构造器内容做补充。

3.static静态代码块

 static{

        

  }

  静态代码块也符合静态内容的特点。随着类的加载而加载,并且

  只加载一次。最先执行。同样不可以访问非静态内容。

 

  静态代码块中的内容只执行一次,跟创建多少个对象无关。

  编译--->执行静态代码块(只执行一次)--->构造方法....等内容。

 

  何时使用?

  当某个内容在创建对象之前需要被执行一次的时候使用静态

  代码块。

 

继承:子承父业。

  有一些类有共性内容(相同的内容),我们把这些共性内容抽取

  出来,抽取到一个新的类中。所有的类都可以使用关键字extends

  继承拥有共性内容的类,那么就可以拥有这个共性类的所有内容。

  这个有共性内容的类称为父类(超类、基类)。继承父类的类叫做

  子类。

 

 继承是java中代码重用的重要手段之一。

 java中的类只支持单根继承。一个类只有一个直接父类。

 继承支持多重继承。儿子继承爸爸,爸爸继承爷爷....

 当一个类没有声明直接父类的时候,默认继承Object

 所有的类都直接或间接的继承了Object Object为类层次结构的根类。

 

 继承通常符合  is-a的关系 dog is a pet

 

继承的语法:

class 子类 extends父类{

 

}

子类继承父类可以拥有父类的所有内容。

---->属性

1>子类可以继承父类的所有属性。

2>子类同样可以继承父类的用private修饰的属性,只是private修饰

  的成员无法在类外访问。但是子类依然会继承来该特性,可以

  使用set/get方法来对该属性进行取值和赋值。

3>当父类有一个属性,子类也有同名属性,用子类对象调用该属性

  调用的是子类的。

4>当父类有一个属性,子类也有,在子类方法中调用属性,调用

  的是子类的,在父类方法中调用该属性调用父类的。

  就近原则!!!

5>父类有一个属性,子类也有,在子类方法中想调用父类的该属性

  使用super.属性来调用父类属性。

*******************

superthis在使用的时候,用法是一样的。

thissuper都不可以使用在main方法。

也不可以使用在静态方法中。

 

this:代表当前对象。

    1>区分同名的局部变量和成员变量。

    2>在构造方法中调用其他构造方法的方法体。this(参数)

super:当前类的父类对象的引用。

     也就是说super不是对象!!!当前类对象有一块内存可以

     指向父类的对象成员。

 

    1.区分同名的父类属性和子类属性

    2.区分被覆盖的父类方法。

    3.子类构造方法中调用父类的构造方法。super(参数)

 

********************

------->方法

1.子类可以继承父类的所有方法。

2.父类有一个方法,子类也有,调用的是谁的?

  首先判断是否覆盖,覆盖调用的是子类的。

  重写 (覆盖) Override

  1.父子类中

  2.方法名相同

  3.参数列表相同

  4.返回值类型相同或者,子类的返回值是父类返回值

    的子类。

  5.访问修饰权限相同,或者子类大于父类。(子类更大方)

  6.子类不能抛出比父类更多的异常。

 

 

  重载 Overload

  1.在同一类中

  2.方法名相同

  3.参数列表不同

  4.与返回值无关

 

3.在子类方法覆盖父类的方法时,在子类中调用父类的方法

可以使用 super.方法(参数);

 

---->构造方法

在没有自定义构造方法的时候JVM会默认分配给一个构造方法

 public 类名(){

         super();

  }

 

 

1.在没有调用其他构造方法(this(参数)|super(参数))的时候,所有的构造方法默认第一句

  都是 super();

2.在构造方法中调用其他构造方法的时候语句必须在第一句。

  所以只能调用一个其他构造方法。

  不允许12 23  31 --->递归构造器!错误的!!!!

3.当父类没有无参构造的时候,一个类中至少一个构造方法必须

  调用父类的有参构造。

 

----->静态方法

1.当父类有一个静态方法,子类没有,子类对象可以调用该方法。

  对象.方法();

2.当父类有一个静态方法,子类也有,子类对象调用该方法

  调用的是子类的。就近原则!

  不是因为覆盖!!

  静态方法不存在覆盖!!!

3.调用静态成员的时候通常不使用对象去调用。而使用

  类名去调用。

 

继承:子承父业。

  有一些类有共性内容(相同的内容),我们把这些共性内容抽取

  出来,抽取到一个新的类中。所有的类都可以使用关键字extends

  继承拥有共性内容的类,那么就可以拥有这个共性类的所有内容。

  这个有共性内容的类称为父类(超类、基类)。继承父类的类叫做

  子类。

 

 继承是java中代码重用的重要手段之一。

 java中的类只支持单根继承。一个类只有一个直接父类。

 继承支持多重继承。儿子继承爸爸,爸爸继承爷爷....

 当一个类没有声明直接父类的时候,默认继承Object

 所有的类都直接或间接的继承了Object Object为类层次结构的根类。

 

 继承通常符合  is-a的关系 dog is a pet

 

继承的语法:

class 子类 extends父类{

 

}

子类继承父类可以拥有父类的所有内容。

---->属性

1>子类可以继承父类的所有属性。

2>子类同样可以继承父类的用private修饰的属性,只是private修饰

  的成员无法在类外访问。但是子类依然会继承来该特性,可以

  使用set/get方法来对该属性进行取值和赋值。

3>当父类有一个属性,子类也有同名属性,用子类对象调用该属性

  调用的是子类的。

4>当父类有一个属性,子类也有,在子类方法中调用属性,调用

  的是子类的,在父类方法中调用该属性调用父类的。

  就近原则!!!

5>父类有一个属性,子类也有,在子类方法中想调用父类的该属性

  使用super.属性来调用父类属性。

*******************

superthis在使用的时候,用法是一样的。

thissuper都不可以使用在main方法。

也不可以使用在静态方法中。

 

this:代表当前对象。

    1>区分同名的局部变量和成员变量。

    2>在构造方法中调用其他构造方法的方法体。this(参数)

super:当前类的父类对象的引用。

     也就是说super不是对象!!!当前类对象有一块内存可以

     指向父类的对象成员。

 

    1.区分同名的父类属性和子类属性

    2.区分被覆盖的父类方法。

    3.子类构造方法中调用父类的构造方法。super(参数)

 

********************

------->方法

1.子类可以继承父类的所有方法。

2.父类有一个方法,子类也有,调用的是谁的?

  首先判断是否覆盖,覆盖调用的是子类的。

  重写 (覆盖) Override

  1.父子类中

  2.方法名相同

  3.参数列表相同

  4.返回值类型相同或者,子类的返回值是父类返回值

    的子类。

  5.访问修饰权限相同,或者子类大于父类。(子类更大方)

  6.子类不能抛出比父类更多的异常。

 

 

  重载 Overload

  1.在同一类中

  2.方法名相同

  3.参数列表不同

  4.与返回值无关

 

3.在子类方法覆盖父类的方法时,在子类中调用父类的方法

可以使用 super.方法(参数);

 

---->构造方法

在没有自定义构造方法的时候JVM会默认分配给一个构造方法

 public 类名(){

         super();

  }

 

 

1.在没有调用其他构造方法(this(参数)|super(参数))的时候,所有的构造方法默认第一句

  都是 super();

2.在构造方法中调用其他构造方法的时候语句必须在第一句。

  所以只能调用一个其他构造方法。

  不允许12 23  31 --->递归构造器!错误的!!!!

3.当父类没有无参构造的时候,一个类中至少一个构造方法必须

  调用父类的有参构造。

 

----->静态方法

1.当父类有一个静态方法,子类没有,子类对象可以调用该方法。

  对象.方法();

2.当父类有一个静态方法,子类也有,子类对象调用该方法

  调用的是子类的。就近原则!

  不是因为覆盖!!

  静态方法不存在覆盖!!!

3.调用静态成员的时候通常不使用对象去调用。而使用

  类名去调用。

 

多态:

  事物的多种表现形态。

  方法的重写与重载也是多态性的表现。

  面向对象:

  父类类型指向子类对象。

  父类名对象名 = new子类();  向上转型

 

多态的对象:

--->属性

1.当父类有一个属性,子类没有,调用该属性,调用的是父类的。

2.当父类有一个属性,子类也有,调用该属性,调用的是父类的。

3.当子类有一个属性,父类没有,调用该属性,编译报错!!!!!

 

--->方法

1.当父类有一个方法,子类没有,调用该方法,调用的是父类的。

2.当父类有一个方法,子类也有,调用该方法,调用的是子类的。

3.当子类有一个方法,父类没有,调用该方法,编译报错!!

 

在多态情况下创建的对象,不可以调用子类特有的内容。

 

--->静态方法

1.当父类有一个静态方法,子类没有,调用该方法,调用的是父类的。

2.当父类有一个静态方法,子类也有,调用该方法,调用的是父类的。

  静态方法不存在覆盖,该对象为父类类型,调用静态方法,

  一定调用的是父类类型对象的共享内容。

  调用静态内容的时候通常使用类名调用。

3.当子类有一个静态方法,而父类没有,调用该方法,编译报错!!!

 

 

以父类类型作为方法的参数和方法的返回值都是多态中的应用。

 

 

 

面向对象:

  父类类型指向子类对象。

  父类名对象名 = new子类();  向上转型

 

 

  子类类型对象名 = (子类类型)父类对象;--->向下转型

  向下转型的前提是存在父子关系。

 

  向下转型都可以成功吗?

  不一定!

  需要判断是否可以转换类型。需要使用运算符:instanceof

 

  对象 instanceof类型 --->返回值:boolean

  判断该对象是否是一个该类型的实例。

  该对象是否可以转换为该类型。

  如果结果为true可以强转,如果为false不可以强转。

 

抽象:模糊、不具体。

抽象方法

访问修饰符 abstract 返回值类型方法名(参数列表);

1.需要用abstract修饰。

2.抽象方法不可以有方法体。

3.抽象方法必须存在于抽象类中。

 

抽象类:

public abstract class 类名{}

         1.抽象类中的属性和普通类一样。

         2.抽象类中可以有普通方法。

         3.抽象类中可以有抽象方法,也可以没有。

         4.抽象类中可以有构造方法。

         5.子类继承抽象父类,

                   1>必须重写父类的所有抽象方法。

                   2>子类也为抽象类。

         6.抽象类无法实例化,不能创建对象。

           不是因为没有构造方法,而是因为一个抽象的模板

           没有资格实例化。

           只能用多态的方式创建对象。向上转型

           父类类型对象 = new非抽象子类();

         7.抽象类可以继承抽象类。也可以继承普通类。

        

 

abstract:抽象的。关键字。

          可以修饰类、方法。

          abstract不可以和staticprivatefinal连用。

 

抽象类和普通类的区别:

         1.抽象类用abstract修饰,普通类

         2.抽象类中可以有抽象方法,普通类不可以有。

         3.抽象类不可以实例化,普通类可以。

 

 

final:最终的、最后的。修饰符,关键字

final可以修饰类、可以修饰方法、可以修饰变量。

1.final修饰的类,不可以被继承。

2.final修饰的方法,不可以被覆盖。

3.final修饰的变量,不可以被更改,为常量,必须初始化。

        

         final修饰的属性,成员变量初始化的方法

         1>直接赋值。初始化该常量

         2>在构造方法中对该常量赋值,在创建对象的同时完成

           对该常量的初始化。

 

 public static final int NUM = 5;

  全局常量。

 

接口:interface  接口是一个特殊的抽象类。

        

         1.属性默认被 publicstatic final修饰,为全局常量。

         2.接口中的方法默认被publicabstract修饰,

           为抽象方法。

         3.接口中没有构造方法。

         4.子类不可以继承(extends)接口,

           需要使用implements来实现接口,子类称为实现类。

           class 实现类 implements接口{

          

           }

           实现类实现接口。

         5.实现类实现接口后:

                   1>必须重写(实现)接口中的所有抽象方法(所有方法)

                   2>或者实现类为抽象类。

         6.接口不可以实例化。

           需要实现类的存在,使用多态向上转型来创建对象。

           接口名对象名 = new实现类名();

         7.接口不可以继承类,也不可以实现类。

           接口可以继承接口,要求实现类重写所有父接口的所有方法。

         8.接口可以继承多个接口,实现类重写所有父接口

           的所有方法。

           interface IA extends IB,IC...{

          

           }

         9.实现类可以实现多个接口。

         10.接口通常不具有is - a的关系。

        

 

一个类可以边继承,边实现。

继承一个类的同时实现多个接口,先继承,后实现。

需要重写所有类或接口中的抽象方法。

class extends父类 implements接口1,接口2...{

 

}

 

抽象类和接口的异同:

相同点:

         1.都可以有抽象方法。

         2.都不可以实例化,需要子类(实现类的存在)

           使用多态的方式创建对象:

           类名(接口)对象 = new 子类(实现类)();

         3.子类(实现类)继承(实现)需要重写所有的抽象方法。

不同点:

         1.抽象类中的属性和普通类一样。

           接口中的属性默认被publicstatic final修饰为全局常量。

         2.抽象类中可以有普通方法。

           接口中的所有方法默认被publicabstract修饰为抽象方法。

       3.抽象类中有构造方法。

           接口中没有构造方法。

         4.声明:抽象类abstract class

                 接口  interface

         5.继承抽象类使用extends

           实现接口使用 implements

         6.抽象类可以继承类、实现接口,实现多个接口。

           接口不可以继承或实现类,接口可以继承接口,可以继承多个。

         7.一个类可以继承一个父类(抽象父类)的同时实现多个接口,

           先继承,后实现。

         8.继承通常具有 is-a的关系

           实现通常没有is-a的关系。