面向对象

面向过程

关注点在过程，用过程中的一个个方法完成功能。
面向对象

设计出发点：更能直接描述问题域中，客观存在的事务
基本思想： 从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类自然思维方式
理解： 
属性和方法从属于对象
按照对象组织代码，更符合对现实问题的抽象
有利于代码的封装，复用，扩展和维护
类和对象

对象：是用计算机语言对问题域中事物的描述。 

类： 描述同一类型的对象的抽象的概念，是对象的模板的描述。 

类是模板，对象是一个实例



变量

成员变量与局部变量的区别 
在类中的位置不同 
成员变量：方法中
局部变量：类中，方法外
在内存堆中 
成员变量：在内存堆中
局部变量： 在内存栈中  
生命周期不同 
成员变量： 静态随类，非静态随对象
局部变量：随方法
初始值不同 
成员变量：有默认初始值
局部变量：没有默认值，必须定义，赋值，然后才能使用    
修饰符不同 
成员变量：可以有修饰符
局部变量： 不能有修饰符
作用域 
成员变量：定义开始到类结束的位置
局部变量：定义开始到方法结束的位置
方法

解决一类问题的代码的有序组合。

重复执行的代码，命名为一个方法，方便重复使用
方便自上而下解决问题
方便代码维护
语法格式



修饰符 返回值类型 方法名 （参数类型 参数名）{
    执行语句
    return 返回值
}

修饰符

权限修饰符
静态修饰符
最终修饰符
参数的传递

把指定的数值，传递给方法中的参数
定义方法时，参数列表中的变量，形式参数
调用方法时，传入给方法的数值，实际参数
形式参数的类型 大于等于 实际参数的类型
返回值类型  大于等于  方法内return的数据类型
值传递和引用传递

基本类型作为参数传递时

值传递，传递的是值的副本，不会改变实际参数的值
形式参数的改变不会影响实际参数的值
引用数据类型作为传输传递时

引用传递，传递的是引用，通过引用会改变实际参数的值
形式参数的改变会影响实际参数的值
差别原因是

基本数据类型，实际值存放在内存栈中，直接操作实际值
值传递时，改变的是副本的值不会改变原始数据
引用数据类型，引用存放在内存栈中，实际值存放在内存堆中，会根据引用找到内存堆中的实际值，对实际值进行操作
引用传递时，是将形式参数建立引用联系到内存堆中的实际值，这样实际参数和形式参数都引用到同一个内存堆中的实际值，因此任何一个改变也会引起另一个改变。
方法重载

一个类中定义多个名称相同的方法，但是参数的类型或者个数必须不同    

同一个类中，方法名必须相同 
重载方法的参数必须不同

参数个数不同
参数类型不同
参数顺序不同
重载只与方法名和参数类型有关，与返回值无关
重载与具体的变量标识符无关
递归结构

自己调用自己，
任何可用递归解决的问题都可用迭代解决
结构： 
递归头： 解答什么时候不调用自身方法
递归体： 解答什么时候需要调用自身的方法
缺陷 
占用内存和耗用多，效率低

一、计算（机械而有效的方式获取问题答案）理论：中心从数学转至计算机科学
1.1 核心问题：计算机的基本能力和限制是什么？


可计算性理论：究竟哪些问题，可通过计算解决？
计算和算法：一阶逻辑谓词可解决的话，就可以用数理逻辑一劳永逸的解决问题。有些问题是不存在算法的。


计算复杂性理论：解决可计算的问题，究竟需要多少资源？
到底是什么原因导致有些问题需要耗用大量资源才能解决？——可以对问题按照性质不同进行分类。


形式语言与自动机理论：为了研究计算，要使用哪些计算模型？
简单明确、功能强大。


1.2 自动机理论：研究抽象机器及其所能解决问题的理论

图灵机：计算机的理论抽象模型，它区分了哪些问题是可计算的，哪些是不可计算的。（P = NP ?）
有限状态机：数字电路、通信协议的设计验证方面等实际问题中有重要应用。
文法、下推自动机：在计算机语言设计和编译器的实现上发挥了重要的作用。

1.3 形式语言
如果说自动机是研究计算的模型，那么语言就是去研究计算的问题或实例。
形式语言：经数学定义的语言。
二、基本概念
2.1 形式语言中的基本概念：字母表 字符串 集合


字母表：符号（字符）的非空有穷集。（类似几何中的点、线，不再做过多定义。）


字符串：由某字母表中的符号组成的有穷序列。


空串：记为 $\epsilon$ （\epsilon），有0个字符的串。

字母表 $\Sigma$ 可以是任意的，但都有 $\epsilon \notin \Sigma$ .



字符串的长度：字符串中符号所占位置的个数，记为 | |
下面给出递归的定义：
$若字母表为 \Sigma，其中 a \in \Sigma,w 和 x 是 \Sigma 中字符组成的字符串$

$|w| = 
\begin{cases}
0,w=\epsilon \\
|x|+1,w=xa
\end{cases}$


字符串x和y的连接：将首尾相接得到新字符串的运算，记为$x\cdot y,或xy$

不满足交换律，满足结合律。



字符串的n次幂，$(ab)^2 != ab^2$


集合A和B的连接：记为$A\cdot B,或AB$


集合A的n次幂

$A=\lbrace{a\rbrace} \\
A^3=AAA=\lbrace{a\rbrace}\lbrace{a\rbrace}\lbrace{a\rbrace}=\lbrace{a^3\rbrace}$

那么，若 $\Sigma$ 为字母表，则 $\Sigma ^n $ 为 $\Sigma$ 上长度为n的字符串的集合。

注意：在学习程序语言设计的时候，需要明确区分字符和字符串，但是在形式语言自动机中，无需明确的进行区分，因为在上下文中它会极其明显。


克林闭包（$Kleene \quad Closure$）


由字母表中任意长度的字符组成的字符串；

$\Sigma * =\bigcup_{i=0}^{\infty} \Sigma^i \\
= \Sigma ^0 \bigcup \Sigma ^1 \bigcup \Sigma ^2 \bigcup \Sigma ^3 ...$

正闭包（$Positive \quad Closure$）

$\Sigma ^+ =\bigcup_{i=1}^{\infty} \Sigma^i \\
= \Sigma ^1 \bigcup \Sigma ^2 \bigcup \Sigma ^3 ... \\$
显然有：

$\Sigma * = \Sigma ^+ \bigcup \lbrace\epsilon\rbrace$.
2.2 语言
定义：若 $\Sigma$ 为字母表且 $\forall L \subseteq \Sigma *$，则L称为字母表 $\Sigma$ 上的语言。比如：

自然语言、程序设计语言
集合语言、数学语言
文字方式描述集合

关于语言：唯一重要的约束就是所有字母表都是有穷的。
2.3 自动机理论中的典型问题：成员性问题
判断给定的字符串 $w$ 是否属于某个具体的语言 $L$ ？即：$w \in L?$

任何所谓问题，都可以转为语言成员性的问题；
语言和问题其实是相同的东西；

2.4 形式化证明方法


演绎法


归纳法
课上有两个例子讲了两种形式的归纳法：对长度的归纳和对结构的归纳


反证法

对象和类的基本概念

Java语言中的对象是对现实生活的模拟，现实生活中的对象存在于现实生活中，Java语言中的对象（实例）在计算机内存中。ps:Java中的对象也称实例。

我们在认识事物时要知道他的属性和功能，能做哪些事情，Java中的对象也是如此，只是叫法不同，属性也称全局变量（也称作成员变量），功能也可称之为方法。

Java语言把一组对象中相同的属性和方法抽象到一个Java源文件中就形成了一个类。

类是对象的模板，对象是类的实例，类只有通过对象才可以使用，但是在写代码时会先写类，在产生对象。类不能直接使用，对象可以直接使用。

类是一种数据类型，是对象的数据类型（不同于int等基本类型：类具有方法）。

类与对象的定义和使用

类的定义：

在Java中定义类，使用关键字class完成。语法如下：

public class  类名 {
	//属性
	属性1类型   属性1;
	属性2类型   属性2;
		…
	属性n类型   属性n;

	//方法
	方法1;
	方法2;
		…
	方法m;
}

先定义类名，再定义属性，最后定义方法。

类名定义规则：类名的命名规则：1、符合标识符命名规范；2、类名必须使用英文字母，首字母应大写，如Hello、People等。3、当类名由多个”单词”组合而成时，每个单词的首字母都要大写。如 Time、Game、Dog、DateUtil等。

对象的定义和使用：

首先声明一个类：

class Person {     // 类名称首字母大写
    String name ;
    int age ;
    public void tell() {        // 没有static
          System.out.println("姓名：" + name + "，年龄：" + age) ;
    }
}

类定义完成后，肯定无法使用，需要创建对象来调用它。类属于引用数据类型，所以对象的产生格式如下：

通过new关键字创建对象，创建对象又称实例化对象。比如：类名称 对象名称 = new 类名称 () ;

此类的声明对象方式为：

Person person = new Person();

使用”.”运算符访问对象的属性和方法。定义方法：对象.属性：表示调用类之中的属性； 对象.方法()：表示调用类之中的方法。下面是对对象的属性和方法的访问方式：

person.name = "小李";
person.tell();

例子：（使用对象操作类）

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 声明并实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

结果为：

姓名：张三，年龄：30

那么，说了这么多，我们在实例化一个类时内存中到底有什么变化呢？

我们从内存角度分析，首先给出两种内存空间的概念：

(1)  堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间。

(2)  栈内存：保存的是堆内存的地址（可以理解为栈内存保存的是对象的名字）



任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。

 

JAVA的类和接口
考试吧(Exam8.com) 2003-05-14 08:00:00 评论(0)条
Java是一种面向对象(OOP)的编程语言；在Java中，面向对象是以类的形式出现的，而对象则是类的实例，所以要学习Java的类首先必须了解面向对象。面向对象编程不同于过程语言或结构化程序设计，他存在对象这个概念，面向对象中的对象不仅是数据结构，还包含和数据结构有关的方法。
一：类
1.类的声明及实例化
类是面向对象关键，可以说没有类就没有对象；类具有两个优点，首先，他允许封装；即将数据和方法封装起来使得这方面的信息和其他程序有效的分开，封装的好处是如果修改了这个类，只要没改变这个类中的方法就不需要动别的程序；类的第二个优点是允许继承。
类由两部分组成，第一部分是类的变量的声明，到二部分类中的方法；以下是创建一个叫test的类：
public class test{ //声明一个类
String name; //类的变量的声明
changtest(){ //类的方法
name="text";
}
}
在上面声明一个类时使用了修饰符"public".在声明类时可以使用三中说明符：public,final和abstract。
public类意味这个类可以被任何对象使用和扩展，而且与他的包无关；
final类则表明这个类没有任何子类；
abstract类即说明这个类是一个抽象类；
如果类声明前没有任何修饰符，则默认为protected类，即只有同一个包中的对象才能使用该类。
前面已经说了类有个优点是允许继承，这就说明新建的类可以使用已建类的变量和方法，这样通过基于简单的类建立较大的类的方法，可以减少许多代码的编写，也减少了在程序中查找和修改错误的工作；以下例子建立一个类MyClass，他继承了类test中所有的变量和方法：
public class MyClass extends test{}
其中类MyClss被称为子类，类test被称为父类或超类.
当创建了类后，就可以用new来创建类的一个实例，并不是所有的类都需要创建他的实例，如果要使用的类中的方法或变量是静态的，就可以不用创建这个类的实例，但是静态的方法只能引用静态的类变量(System类的out变量是一个例外)；以下例子创建类test的一个实例：
test mytest=new test();
创建类的实例是为了要引用这个类中的变量或方法，前面已经为类test创建了一个实例mytest，如果类test中包含了一个方法changtest()，可以用如下方式来引用：
mytest.changtest();
2.类的变量
声明类的变量和声明类类似，前面可以跟上修饰符；变量有以下几种修饰符：
public--变量在所有类中可视；包括包中的类和所有子类。
protected--变量可以被当前类中的所有方法访问，但是在当前包以外的类中不可见。
private--变量只能被当前类中的所有方法访问。
static--声明此变量为静态变量。
final--该修饰符说明此变量的值在运行期间不能被修改。
为什么不把所有变量都声明成全局变量呢？有两个原因：第一个原因是这样做将浪费大量的内存；第二个原因是如果把所有变量都声明成全局变量会使得程序难以阅读。
在类中有两个特殊的变量：this和super；
在以下两种情况中需要使用this变量：
在类中有两个变量同名，其中一个属于当前类而另一个属于某个特定的方法。
当某个类需要将类作为参数传递给某个方法。
以下情况需要使用super变量：
当覆盖方法时，有时候希望使用老方法中的代码，这是可以使用super变量来获取原来的代码。
3.有时候为了做一个项目需要建立一大堆的类，这些类文件就象没有子目录或文件夹的硬盘一样是杂乱无章的，为了方便管理所以引入了包，这样就可以将有着相关的类放在一个包中，包就象是文件夹或子目录。要想使某个类成为包的成员，必须使用package来声明他，要注意的是package语句必须是文件的第一行，package语句前面除了空白和注释不能有任何东西；例如：
package packagename;
如果要引用包packagename中的类则用以下方式：
import packagename.*;
以上命令是引用包packagename中的所有类，如果你只引用这个包中的某个类可以用以下方式：
import packagename.classname;
也许有人会问引用整个包中的类不好吗？为什么还要指定是某个类呢？原因有以下几点：
首先当引用不在本地机器上的整个包，程序将通过网络将包的所有文件都拖过来，如果这个包有上千个类，而你只使用其中很少的部分，将浪费很多资源。
如果引用的两个包中有共享的文件名(例如包pack1中有个叫classname的类，pack2中也有个叫classname的类，如果你使用import pack1.*;import pack2.*)，你的系统就要崩溃了。
4.下面就用一个例子来详细介绍如何创建，实例一个类：
**********************************************************************************************
//声明类tools是属于包mypack
package mypack;
//声明一个公共的类tools
public class tools {
public tools() {
}
/**
*声明类的方法replace()
*此方法在一个字符串里查找某个特定的字符串，如果找到，则将这个字符串替换成另外一个字符串
*如果找到返回替换后的字符串，如果未找到则返回原字符串
*replace(整个字符串，被替换的字符串，替换后的字符串)
*值得说明的是由于我是使用while，所以如果原字符串为"ababcdcd"，要将字符串"ab"替换成"e",则输出为"eecdcd"
*如果只是想将原字符串中的第一个被找到的字符串替换掉，则将while换成if即可
*/
public String replace(String allstr,String replstr1,String replstr2) {
while(allstr.indexOf(replstr1)!=-1)
allstr=allstr.substring(0,allstr.indexOf(replstr1))+replstr2+allstr.substring(allstr.indexOf(replstr1)+replstr1.length());
return allstr;
}
public static void main(String[] args) {
//生成类tools的实例t
tools t=new tools();
//用类tools的方法replace()将字符串"abcd"替换成"adcd"并输出到控制台
System.out.print(t.replace("abcd","b","d"));
}
}
***********************************************************************************************
二：接口
1.前面讲了类有个重要的特性就是继承,但是一个类只能有一个父类,为了实现象C++中的多继承性,就必须使用接口;接口和类非常相似,接口用于定义几个类具有的但又不在这些类中定义的功能,通过在接口中设置这些方法,描述出共同的特性,至于如何实现则是类本身的事。由于接口的这个特性，就意味着在接口中只能定义抽象的方法而不能有方法体；这又于类的定义相违背了，这就造成了接口不能扩展类。另外接口还有一个与类不同的地方是接口声明的变量必须是静态变量。下面语句定义了一个接口：
public interface interf
值得注意的是，如果使用了扩展的接口，必须将老接口的方法和新接口的方法全部覆盖掉。在覆盖方法时方法名和参数都必须和老方法一致，如果只是方法名相同而参数不同那将重载该方法，但不会覆盖该方法。例如：
public interface interf {
......
public void meth() {
......
}
public void meth(int a) {
......
}
......
}
展开全文