来黑马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 作者信息 |
|
收藏
淘帖
踩
