您的位置：首页 > 职场人生

[黑马程序员]（第6-9天）面向对象（上）

2015-07-21 17:47 453 查看
------- android培训、java培训、期待与您交流！ ----------
来黑马java基础班，已经第三天了，这两天看完了整本书，这里是笔记。

面向对象的概念

类与对象

构造方法

this和static关键字

内部类

java的帮助文档

面向对象的概念：（很多需要记忆的理论知识）

面向过程就是分析解决问题所需的步骤，然后用函数把这些步骤一一实现

面向对象就是把解决的问题分为多个独立的对象，然后通过调用对象的方法来解决问题

优点：当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护

面向对象的三大特点：封装性，继承性，多态性。

封装性：

将对象的属性和行为封装起来，不需要让外界知道实现细节，这就是封装思想。

所谓类的封装，是指在定义一个类时，对该类里面的属性私有化，即使用private关键字来修饰，然后提供一些public修饰的公共方法，比如获取属性所用的getXxx()以及设置属性所用的setXxx()

继承性：

通过继承，可以在无须重新编写原有类的情况下，对原有类进行功能扩展。

在java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称为子类，子类可以自动拥有父类所有可继承的属性和方法，在程序中，用extends来表示类的继承

优点是增强了代码的复用性为程序的修改补充提供了便利

多态性：

多态性指的是允许出现重名现象，它指一个类的属性或方法被不同的类继承后，它们可以具有不同的数据类型以及表现出不同的行为，这使得同一个属性和方法在不同的类中有不同的语义

在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态

(Animal a  = new Dog()，突然想到：

Map map = new HashMap();

Map map = new TreeMap();

好像也是多态了)

构造方法：

如果需要在实例化对象的同时就为这个对象的属性进行赋值，可以通过构造方法来实现(静态代码块为静态属性赋值)

在new Object()时除了会实例化Object对象，还会调用构造方法Object()

(在java中的每个类都至少有一个构造方法，如果一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，这个默认的构造方法没有参数也没有方法体，什么也没有）

如果我们并没有定义无参的构造方法，只是定义了一个有参的构造方法，系统将不再自动生成无参的构造方法，为避免出错，最好有了有参的构造方法，再定义一个无参的

this关键字：

this在程序中的三种常见用法：

1）通过this关键字可以明确的去访问类的成员变量，而避免了与局部变量名称冲突的问题

2）调用成员方法

3）可以在一个构造方法中用this调用另一个构造方法（但要位于第一行）

69

class Person(){

        Person(){

                System.outprintln("freosa");

        }

        Person(int i ){

                this();

                System.out.println("mad max");

        }

}

public class Example01{

        public static void main(String[] args){

                

        Person p  = new Person(22);

}

垃圾回收：

System.gc()

finalize()---被内存释放掉之前调用

class Person {

        public void finalize(){

                System.out.println("啊！！我被当垃圾回收了！！不要啊！！我会回来的");

        }

}

public class Example02 {

        public static void main(String[] args){

                Person p1 = new Person();

                Person p2 = new Person();

                p1 = null;

                p2 = null;

                System.gc();

                for(int i = 0 ; i <10000000 ; i++){

                }

        }

}

static关键字：

static的作用是，指定该数据在内存中只有一份，而且这份数据能被一个类的所有实例对象所共享

（static关键字只能用于修饰成员变量，不能用于修饰局部变量）

静态代码块：

在java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块叫静态代码块

静态代码块特点：

最先执行（先于main()方法）

通常用静态代码块来对成员变量进行初始化

单例模式：

设计模式：为解决问题或完成需求，经过大量的实践总结和优选后的代码结构，编程风格和解决问题的思考方式。

之前就接触过单例模式，即无法直接new

Calendar c = Calendar.getInstance()

DateFormat df = DateFormat.getDateFormat();

有两种实现方法：

class Single {

        private Single(){}                                                //用private修饰构造方法，使外部类不能实例化Single类

        private static Single INSTANCE = new Single();                        //使用静态变量INSTANCE来引用该类的唯一实例对象

        public static Single getINSTANCE(){                                //静态方法让外界能获取到这唯一的实例对象

                return INSTANCE;

        }

}

检验：

public class Example03{

        public static void main(String[] args){

                Single s1 = Single.getINSTANCE();

                Single s2 = Single.getINSTANCE();

                System.out.println(s1 == s2);

        }

}

结果为true

第二种实现单例模式的方式：

class Single {

        private Single() {}

        public static final Single INSTANCE = new Single();

}

Single s = Single.INSTANCE;

内部类

成员内部类，静态内部类，方法内部类

成员内部类：

特点：内部类可以在外部类被使用，并能使用外部类的成员

但如果非外部类要实例化这个内部类，那么格式就有点奇怪了：

Outer.Inner inner = new Outer().new Inner();

外部类名.内部类名 变量名  = new 外部类名().new 内部类名();

例子：

public class Outer {

        int num  = 4;

        public void test(){

                Inner inner = new Inner();

                inner.shout();

        

        }                        

        class Inner {

                public void shout(){

                        System.out.println("num="+num);

                }

        }

}

public class Example04 {

        

        public static void main(String[] args){

                Outer outer = new Outer();

                outer.test();

        }

}

静态内部类：

与成员内部类的区别：

1)可以不用实例化外部类就可以得到实例对象

格式：

外部类名.内部类名 变量名 = new 外部类名.内部类名()

对比一下：

Outer.Inner inner = new Outer().new Inner();

Outer.Inner inner = new Outer.Inner();

2)静态内部类只能访问外部类的静态成员

（注意：在静态内部类中可以定义静态的成员，在非晶态的内部类（成员和方法）不能）

方法内部类：

指在成员方法中定义的类，它只能在当前的方法中被使用。

它也可以访问外部类的成员变量

class Outer {

        public void test() {

                class Inner{

                        public void inner(){

                                System.out.println("freriosa");

                        }

                }

                Inner i = new Inner();

                i.inner();

        }

}

Java的帮助文档：

这里主要还是解释文档注释：格式如下

/**

*

*

*/

有@标记的都是有特殊作用的：

@author：作者

@version：版本号

@param 参数 ： 参数的解释

@return ：表示方法的返回值代表的意义

/**

*Title类：Person类<br>

*Description:通过Person类来说明java的文档注释<br>

*Company:Freedom.inc

*@author:morton

*@version:1.0

*/

public class Person {

        public String name;

        /**

        *这是Person类的构造方法

        *@param name Person的名字

        */

        public Person(String name){

        //执行语句;

        }

        /**

        *这是read()方法的说明

        *@param bookName 读的书的名字

        *@param time 读书的时间

        */

        public void read(String bookName , int time){

                //代码体（执行语句）

        }

}

再cmd中的代码是：

javadoc -d . -version -author Person.java

-d表示注释文档储存方法

.表示当前的目录

-version 版本信息

-author 作者信息
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航