A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© mortonnnn 中级黑马   /  2015-7-18 00:09  /  534 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

来黑马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 作者信息

2 个回复

倒序浏览
速度这么快?两天就到面向对象???
回复 使用道具 举报
fantianfei 发表于 2015-7-18 00:20
速度这么快?两天就到面向对象???

是的,我以前有一定的基础吧,哈哈~
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马