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