Java面向对象学习阶段小结

原创 2015年07月08日 18:53:59


一、面向对象基础

OOA 面向对象分析

OOD 面向对象设计

OOP 面向对象编程

OOT 面向对象测试

 

 类是对象的抽象,对象是类的实例

 类是具有相同属性和行为的一组对象的抽象

 在软件系统中,我们用类来模拟现实生活中的实体

 

 万物皆对象,对象因关注而产生,对象简单点说就是“东西”

 对象=属性+行为,属性:这个对象身上的值数据,行为:表明该对象能够做什么事情

 类是抽象的概念,对象是用类的生成,类就像是个模板

 结构化与OO的区别

 在结构化编程中,程序围绕着要解决的任务来设计

 在面向对象编程中,程序围绕着问题域中的对象来设计

 

 .class 又称为类文件

 java面向对象的三大特征:

 1.封装(类的{****},信息的隐藏(publicprivate protected 默认、组装等等)

 2.继承

 3、多态

 java中属性(成员变量)、行为(成员方法)

 在定义一个类时;基本数据类型初始化为0,引用类型初始化为nullcharASCii0,布尔型为false

方法=声明+实现,其中声明是由访问修饰符、返回类型、方法名、参数列表组成,实现是{花括号}中的内容

变量的作用域:在哪声明在哪用,哪儿是指它所处的花括号||圆括号里面的变量作用域是圆括号后面的花括号里面使用

类是模板,对象才是真正的具体存在! String 类等引用类型占4个字节

基本数据类型方法里面对其操作改变,外界不能看到对其改变,而引用则都会改变,因为它们指向同一个对象·

java的垃圾回收条件:如果一个对象没有任何引用,那么就具备了被GC回收的条件如果我们想主动通知垃圾回收机制,则使用语句 " 对象=null;"

GC:跟程序平行运行的独立线程,我们不能控制的,不能够干涉垃圾回收 匿名对象:如intb=new Employee().add(a);匿名对象只能用一次,若要使用多次,则需要给对象起名

关于访问修饰符 public 同一个项目的任何类都能访问, private只有自己能用,默认型的只有同一个包中的才能操作,

protected自己或者是子类能用

Thisjava中的一个内置对象,表示当前对象,谁使用则指向谁; 对私有属性的操作方法中,getset方法中用this

java标准类的书写方法javaBean:为私有属性提供符合命名规范的Get(),Set()方法

包用来组织类,根据特定的功能领域来划分包如果在一个类中要使用同一个名称一样的类时,为了避免重名冲突,如 java.sql.Date 中的Datejava.util.Date 时就应该使用包的全路径(类全称)来区分。

 

二、方法

 

类方法的声明与调用

 

方法调用栈:用来改变程序运行顺序

 

调用方法时有三种情况:

 

1.方法返回一个值。在这种情况下,一个基本数据类型或者引用类型被传回给方法的调用者。

 

2.方法不返回一个值。在这种情况下,返回值被声明为void

 

3.方法抛出一个异常给方法的调用者。(异常处理机制)

 

方法签名

 

方法的签名包括方法名、参数列表、返回值的数据类型等信息

 

public static void main(String[] args)

 

public 访问修饰符,代表该方法在哪些地方可以被调用到

 

static 可选修饰符,还有privatesbstract final native

 

void 返回类型,只能有一个返回类型

 

mian 方法名,用在方法调用

 

(String[] args) 参数列表

 

注:public static 的位置是可以交换的,交换后没有区别

 

   args形参名字是可以换的

 

   String[] args  等价于 Stringargs[]C语言写法)

 

形参:用在声明传递到方法中的数据的类型,只有参数的形式,而没有具体值

 

实参:用在调用时候,传入的值要和形参保持一致(如:顺序,类型,个数)

 

计算机在调用方法时,看方法名和参数列表

 

方法的重载:只能在一个类中,有多个同名方法,但是参数列表不一样

 

封装:组装(在类中定义属性、行为),隐藏(访问修饰符的应用)

 

继承:

 

多态:相同的行为,不同的实现。包括方法(自定义方法、构造方法)的重载。

 

构造方法,只在New中使用,用来产生对象。

 

1、没有返回类型 2、方法名与类名保持一致 3、如果不写,会有默认的构造方法 4、构造方法可以重载多个(JavaBean要求必须要有公共的

无参构造方法,由SUN公司的白皮书规定的)

 

否者如果我们自定义了一个带参数的构造方法,那么系统则不会识别默认的构造方法

 

作用:产生对象

 

一个对象的创建流程:在堆中划分空间,在该空间中划分属性,对属性初始化,执行自定义的构造函数中的代码

 

构造方法的thisthis()指代调用本类的其他构造方法(包括有参或者无参),只能写在构造方法的第一句。

 

标准的规范JavaBean写法:

1.必须要有公共的无参构造

2.为所有属性提供符合命名规范的Get/Set方法;

 

方法补充:

方法分为:定义和使用

方法=方法签名+方法实现

 

方法签名格式:

 

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

 

方法实现部分;

 

......

 

}

 

方法名:是用来标识一个方法。

 

方法的设计:注意粒度,一个方法只做一件事情,一个方法不要超过100行。这样写方法便于控制流程

 

return用在viod方法中,后边不加返回值,表明是将该方法终止

 

三、数组

数组:是一种数据类型,它是最简单的集合,数组的存放形式是“引用”。

 

定义语法: int[] a=new int[5];java标准)

 

          int a[]=new int[5];(C语言的定义习惯);

 

          a的类型是int数组,a只是个引用,占4个字节,a是一个指向new 后的存放在堆中的数组对象,初始化数据,最后再复制。

 

数组的三大特点(也是缺点):

 

1.数组只能存放相同的数据类型

 

2.数组元素的存放必须是在连续内存地址空间中。通过下标(转化为偏移量)进行访问数组元素

 

3.数组长度一旦确定,不可变

 

访问:通过下标操作。

 

数组用来操作某些批量数据。

 

总的来说,对一个容器的操作就是增删查改(CRUD),create  read  update delete

四、继承

    表示类与类之间的关系,在一些类中发现他们具有相同的行为和属性,这时候我们可以通过抽取,把他们放到父类(基类)身上,其他属性方法只需要把他们实现在子类(派生类)中。

 

定义:在面向对象编程中,可以通过扩展一个已有的类,并继承该类的属性和行为,来创建一个新的类,这种方式称为继承。

 

如何判断类具有继承关系

类与类的关系:

1.has-a(组合)

2.is-a(继承)

 

java是单继承,内存叠加。

 

在子类的构造方法中super(实参)"super."当前对象的父类部分。表示继承父类的构造方法,只能写在子类的构造方法第一句,可以默认一个super()

 

子类重写父类方法的规范:

1.方法名与父类保持一致

2.参数列表要保持一致

3.返回类型必须保持一次

4.子类方法的访问修饰符必须大于或等于父类的

5.抛出的异常不能比父类多

 

thissuper的区别:

this"."操作符:代表当前对象,可以操作到当前类的所有属性和行为,也可以操作到当前类父类访问修饰符所允许的属性与行为;绝大部分时候使用this

super"."操作:代表当前对象的父类对象部分,只能操作到当前类父类访问修饰符所允许的属性与行为。只有在调用被重写方法的父类实现时,才使用super

 

this"()"操作符:调用本类的指定构造,只能写在构造方法的第一行,没有默认

super"()"操作符:调用父类的指定构造,只能写在构造方法的第一行,即this()不能与super()在同一个构造方法中不能共存,默认为父类的公共无参构造

 

构造方法与继承:子类不能继承父类的构造方法

 

final关键字的用途:

1.写在类的定义前面,这表明这个类不能被继承,即不能拥有子类;最经典的finalString类。

2.写在变量定义的前面,规定了该变量是个常量;finalpublic class A{ .....} public final class A{......}是等价的,final是个可选修饰符

3.写在方法签名前面,该方法不能被重写。

 

五、static与访问修饰符

 

访问修饰符:

类的每一个成员(属性和行为)都有一个访问修饰符,用来判断谁可以访问该成员。

 

范围:

public(同一个项目)

protected(除了不同包的非子类不能用,其他都能用)

默认的(这个没有访问修饰符,只有同一个包的可以用)

private(只有自己可以用)

 

static关键字(可选修饰符):

 

一、被static修饰的属性或者方法叫类属性或者类方法

 

属性

特点:1.全类共享一个值,因为它没有存放在对象上,而是存放在数据段的静态区中

     2.它的访问可以没有对象,可以利用类名直接访问,是因为它在加载期而不是执行期就被放入内存(区别于对象)

 

结论:1.大部分变量属性由于是根据对象的不同而又不同的值,所以很少设计成static的;

     2.常量属性可以无条件的设计成static的。例如:用在定义类的常量属性时 public static final int MAX_VALUE=100;全类共享该属性值,而且都不能修改。

 

方法

特点:1.静态方法只能访问或调用静态属性或者静态方法,可以通过类名直接访问

     2.非静态方法既可以访问非静态属性或者方法,也能访问静态属性或者方法

原因:静态方法是首先被加载的,此时非静态方法还没被加载,所以不认识它们。

结论:我们通常只把工具类的工具方法设计为static的,不用操作对象的属性

 

特例:public static void main(String[] arg0)方法,Math.xx()方法

 

小结:

类的定义所考虑

1.属性:变/常量;公开、保护、私有、默认;基本/引用;静态/非静态

2.构造方法:有参/无参

3.方法:所需的方法、get/set方法、工具行为

4.代码块

5.内部类

 

二、静态代码块(静态初始化块)

    代码块是指如{....}的一组代码

   static{....}main()方法执行之前就能加载类。

作用:如果需要在加载期做一些预处理动作,就写成static静态代码块

 

三、非静态代码块(对象初始化代码块):

   {...}没有static修饰的代码块。

    对象初始化块是在本类的构造方法在调用之前(在本类的父类构造方法之后),预先做一些初始化工作,使用率低,原因是他的功能在部分上是跟构造方法重复的。

 

有继承关系的是要先加载父类,再是子类。

 

static:一定与对象无关,只与类有关,类加载时候执行

 

内部类:

在类的内部再来定义类,内部类所在的类称为外部类。内部类仍然是一个单独的类,它是需要编译产生自己独立的.clas文件,也需要实例化后才使用,只不过是跟内部类使用范围有区别。

 

分类:1.根据位置不同:成员内部类(写在方法外边,跟正常类一样,具有修饰符),局部内部类(这个类是在定义在外部类的某个方法里面的,只能在本方法中使用,没有访问修饰符)

     其中,成员内部类特例,分为static内部类(这个内部类可以通过外部类的内名的"."操作访问到),和普通的内部类。

     其中,局部内部类的特例为匿名内部类,多用在接口上面。格式如:new Object(){属性,行为}.XX();

参考代码:

  1. Static关键字用法

    Persion.java文件

    packagecom.lovo.bean;

     

    publicclass Person {

    //静态代码块,静态初始化块

    //作用:如果需要在加载期做一些预处理动作,就写到这里

    static{

               System.out.println("静态初始化块");

    }

    //对象初始化块

    //在本类的构造方法被调用之前执行(在父类构造方法之后),预先做一些初始化动作。使用率低,

    {

               System.out.println("对象初始化块");

    }

    public int a;//属性

    public static int b;//类属性或者静态属性

    //1、全类共享一个值;——它没有存放在对象上,而是单独存放在数据段的静态区

    //2、可以没有对象,用类名直接方法;———它在加载期(之后才是执行期)就被放入内存

    //结论:大部分变量属性由于是根据对象的不同而有不同的值,所以很少设计成static

    //常量属性可以无条件设计成static的。

    public Person(){

               System.out.println("构造方法!");

    }

    public void hello(){

               this.a = 10;

               this.b = 100;

               this.byebye();

               System.out.println("Hello");

    }

    //类方法或静态方法

    //静态方法只能访问或调用静态属性和静态方法

    //非晶态方法既能访问调用非静态属性和方法,也能访问调用静态属性和方法

    //原因:静态方法是首先被加载的,此时非晶态的还没有被加载。所以不认识它们

    public static void byebye(){

    //                 a = 10;//无法访问非静态属性

               b = 100;//只能访问静态属性

    //                 hello();//无法调用非静态方法

               System.out.println("ByeBye");

    }

    //结论:我们通常只把工具类的工具方法设计为static

    }

     

    TestMain.java文件

    importcom.lovo.bean.Person;

     

    publicclass TestMain {

     

    /**

     * @paramargs

     */

    public static void main(String[] args) {

               // TODO Auto-generated method stub

               //1、测试static属性

    //                 Person.b = -100;

    //                

    //                 Person p = new Person();

    //                 p.a = 10;

    ////             p.b = 100;

    //                

    //                 Person p1 = new Person();

    //                 p1.a = 20;

    ////             p1.b = 50;

    //                

    //                 Person p2 = new Person();

    //                 p2.a = 30;

    ////             p2.b = 20;

    //                

    //                 System.out.println(p.a);

    //                 System.out.println(p.b);

    //                 System.out.println("================");

    //                 System.out.println(p1.a);

    //                 System.out.println(p1.b);

    //                 System.out.println("================");

    //                 System.out.println(p2.a);

    //                 System.out.println(p2.b);

              

              

               //测试static方法

    //                 Person p = new Person();

    //                 p.hello();

    //                 p.byebye();

    //                

    //                 Person.byebye();

              

              

               //测试static代码块

              

               new Person();

               new Person();

               System.out.println("Hello");

              

              

    }

     

    }

     

    ②Static修饰的代码块、实例代码块与继承

    Father.java代码:

    publicclass Father {

    static{

               System.out.println("父类静态初始化块");

    }

    {

               System.out.println("父类对象初始化块");

    }

    public Father(){

               System.out.println("父类构造方法!");

    }

    public void test(){

               System.out.println("父类的test方法");

    }

     

    }

    Son.java文件

    publicclass Son extends Father{

    static{

               System.out.println("子类静态初始化块");

    }

    {

               System.out.println("子类对象初始化块");

    }

    public Son(){

             System.out.println("子类构造方法!");

    }

    public void test(){

               System.out.println("子类的test方法");

    }

    }

    测试类

     

    publicclass FSTest {

     

    /**

     * @paramargs

     */

    public static void main(String[] args) {

               // TODO Auto-generated method stub

               new Father().test();

               new Son().test();

              

    }

     

    }

     

    该程序运行结果为:

    父类静态初始化块

    父类对象初始化块

    父类构造方法!

    父类的test方法

    子类静态初始化块

    父类对象初始化块

    父类构造方法!

    子类对象初始化块

    子类构造方法!

    子类的test方法

    内部类

    OutClass.java

    publicclass OutClass {

     

    public int a;

     

    // 成员内部类

    public class InnerClassA {

               private int b;

     

               public int getB() {

                        return b;

               }

     

               public void setB(int b) {

                        this.b = b;

               }

    }

     

    // 静态内部类

    public static class InnerClassC {

               private int d;

     

               public int getD() {

                        return d;

               }

     

               public void setD(int d) {

                        this.d = d;

               }

    }

     

    public void hello() {

               // 局部内部类

               class InnerClassB {

                        private int c;

     

                        public void hello() {

     

                        }

               }

               // 匿名内部类

               new Object() {

                        private int e;

     

                        public int getE() {

                                 return e;

                        }

     

                        public void setE(int e) {

                                 this.e = e;

                        }

     

                        public void fuck() {

                                 System.out.println("TTM累了");

                        }

               }.fuck();

     

    }

     

    public void byeBye() {

               // 局部内部类

               class InnerClassB {

                        private int c;

     

                        public void hello() {

     

                        }

               }

    }

    }

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

第一阶段:Java初级 ------- 面向对象基础

学面向对象用了些时间呢,难点不是很多,知识点的确蛮多的,知识点相互很灵活。算是对面向对象有了基本了解了吧。面向对象 类 对象。    类就是模版,对象就是实例。--------------------...
  • ICCPP
  • ICCPP
  • 2011-05-09 15:16
  • 290

java学习阶段小结(中级)

1 html   ==>  iframe   form(action , method(get/post)  , enctype)   frameset  (***) 2 css  &...

黑马程序员--第一阶段3.面向对象--第10天

-------------------- android培训、java培训、期待与您交流!--------------------     异常 l 异常定义了程序中遇到的非致命的错误, ...

黑马程序员--第一阶段3.面向对象--第9天

-------------------- android培训、java培训、期待与您交流!--------------------     抽象类 java中可以定义一些不含方法体的方法,...

黑马程序员--第一阶段3.面向对象--第8天

-------------------- android培训、java培训、期待与您交流!--------------------     类的继承 继承格式:class 子类名 ...

黑马程序员--第一阶段3.面向对象--第6天

-------------------- android培训、java培训、期待与您交流!--------------------   构造方法的特征 它具有与类相同的名称; ...

黑马程序员--第一阶段3.面向对象--第7天

-------------------- android培训、java培训、期待与您交流!--------------------   函数的参数传递 —基本数据类型的参数传递:   ...

JavaScript知识点之“面向对象小结”

首先看面向对象的继承实现代码示例: // define the Person Class   function Person() {}      Person....

【设计模式】面向对象小结——重写与重载

如果没有基本的抽象思想,将具有相同属性和功能的对象进行整合,那么也就没有面向对象技术,更不可能产生面向对象特点。所以,抽象是核心,是基本;如果没有封装、继承和多态,那么类与类、对象与对象、类与对象之间...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)