java面向对象总结.doc

面向对象

面向对象是一种思想，能让复杂的问题简单化，让我们角色从执行者变成指挥者，不要知道过程，只要知道结果。（一切皆对象。）
描述一个事物，其实就是在描述事物的属性和行为。
对象的特点在于封装数据，数据包含着属性和行为。
我们用类来描述一个事物，然后引用类来建立一个对象。
也可以在本类建立一个主函数来中创建本类对象，这个叫在本类中创建本类对象。
一般一个程序可以由很多个类组成，也可以有多个主函数，但一般有一个主函数就可以。
格式：引用类名 对象名=new 构造函数名（参数）；
例：class DuiXiang{}
则建立对象为：DuiXiang mingZi=new DuiXiang（）；
如果要实现功能，则格式为：
mingZi.变量或函数名（）；

（string是java中的字符串。 String类是不可变的,对String类的任何改变,都是返回一个新的String类对象。 String 对象是 System.Char 对象的有序集合，用于表示字符串。String 对象的值是该有序集合的内容，并且该值是不可变的。）
面向对象主要的部分：(类和对象的关系，封装（机箱故事），继承，多态，构造函数，this，static，内部类，抽象类，接口)

面向对象之封装

函数是最小的封装体。类也是一个封装体。
private:私有的，权限修饰符，用来修饰类中的成员（成员变量 、成员函数），其只在本类中有效。
每个成员变量通常都会对应两个访问方式：一个设置，一个获取。
注意：私有仅是封装的一种表现形式。
因为语句都必须在函数内，所以，私有化后，再提供访问方式，就可以在访问方式的函数内实现变量控制。这样就提高代码的健壮性。
一般进行封装，要对类中的大部分属性都隐藏，最低权限是private。
类里有一个setXxx函数（一般返回值是void，直接获取，要带参数）和getXxx函数（有返回值类型，但一般没参数,getXxx之后一般用一个变量来接收:string x=p.getXxx
），那代表一定有一个私有化属性。
成员变量都有初始化值， 局部变量可以没有。
举例：
class XueSheng
{
private String name；
public void setName(String name)//这个函数方便以后赋值
{
this.name=name;
}
public String getName()//这个函数是方便以后有需要调用的，比如以后要打印name的值
{
return name;
}

构造函数：

函数名与类名一致，不用返回值类型，不可以用return，主要用来初始化对象。
对象一建立，就默认调用其构造函数。一个对象一建立，就有其默认的属性和行为。（如一个人刚出生就会呼吸，哭...）。
如果我们没有指认，那么类建立就会默认建一个构造函数（类名（）{}），不然对象无法初始化，也就无法建立。（注意：只要我们有指认，那么就不会默认建构造函数）
其与普通函数的区别除了写法上之外：
1，构造函数只在对象建立时运行一次，不再运行了，而普通函数可以调用多次，另外，构造函数是用来初始化对象的，而一般方法是用来添加对象具备的功能。
何时我们要手动添加构造函数：当我们分析事物时，该事物存在一些特性或行为，那么我们就给其定义一个构造函数，如果有变量参与运算，那么我们就给构造函数定义一个参数。
构造函数写法举例：
class Person
{
Person(String name,int age)
//注意：在新建一个对象时要加上参数进行区分，因为一个类可以放很多个构造函数。
//比如：Person p =new Person（"fada",20）
{
this.name = name;
this.age = age;
}

构造代码块：

1，所有对象在建立时都先执行构造代码块初始化，再执行构造函数初始化。
2，作用：当所有对象有共性时，那么就可以定义一个构造代码块（例如：所有小孩先出来就是哭，然后才有其它的属性）
构造代码块的写法(就是在类里面用一个大括号)举例：
class Person
{
{
System.out.print("fada")
//这样一写，那么以后每次建立一个构造函数时便先初始化这个构造代码块
}
}

this关键字的用法

This在类中就是三个代表：代表对象的成员变量，在函数中代表对象调用函数，代表类中的构造函数。

格式：this.变量=变量；
this是用来区分局部变量和成员变量同名时的关键字，因为如果在构造函数里比如（name=name），那么其是赋值给他本身，而不是赋值给类里面的name。
何是用this？当定义类中的函数时，需要调用该函数的对象时，这个时候就用this来表示这个对象。
但凡本类功能内部使用到了本类对象，用this表示。
看到this就是有代表对象，代表哪个对象就看其所在功能被哪个对象调用。
这样就知道谁在参与运算。

例：
class Person
{
private String name;
Person(String name)
{
this.name = name;//this.name=p1.name；
}
}
class PersonDemo3
{
public static void main(String[] args)
{

Person p1 = new Person("fada");

this的应用之定义类中函数的调用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
但凡本类功能内部使用了了本类对象，都用this表示。
例：
class Person
{
private String name;
Person(String name)
{
this.name = name;//this.name=p1.name；
this.fada();//其实就==p1.fada();
//这里写这p1是因为p1这个对象在调用这个函数。一句话，谁调用它就在代表谁。
}
private int age;
Person(int age)
{
this.age = age;
}
public void fada()
{
System.out.println("fada");
}
/*
需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
*/
public boolean compare(Person p)
{
return this.age==p.age;

}
}

class PersonDemo
{
public static void main(String[] args)
{

Person p1 = new Person(20);
Person p2 = new Person(25);
//因为是两个人比，所以要先建立两人的对象
boolean b = pare(p2);
//这里定义了一个布尔型变量去接收p1调用compare函数的值
System.out.println(b);

另一种this用法：格式this（变量）
用于构造函数间的相互调用，而且只能放在构造函数的第一行。
然后先初始化其this调用的构造函数，再初始化本身的构造函数。
其实this(变量)；=new 构造函数名（变量）；（因为所有构造函数名是一样的，都是重载函数，所以，通过变量来标记构造函数，用this去引用）
例：
class Person
{
private String name;
private int age;

Person()
{
System.out.println("person run");
}
Person(String name)
{
This();
this.name =name;
}
}

Static（静态）关键字：

static是一个修饰符：
三种修饰：修饰类的变量、方法和构造代码块。静态方法只能直接引用和访问静态变量和方法
注意（函数即方法，对象也叫实例）
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。 　　声明为static的变量称为静态变量或类变量。可以直接通过类名引用静态变量，也可以通过实例名来引用静态变量，但最好采用前者，因为后者容易混淆静态变量和一般变量。静态变量是跟类相关联的，类的所有实例共同拥有一个静态变量。 关键点：静态变量与实例变量的区别：静态变量也叫类变量，为所有对象所共有，所以一个对象的变量值改变，那么所有对象的值一起发生改变。
而实例变量则是各自独立的不受影响。
　声明为static的方法称为静态方法或类方法。静态方法可以直接调用静态方法，访问静态变量，但是不能直接访问实例变量和实例方法。静态方法中不能使用this关键字，因为静态方法不属于任何一个实例。静态方法不能被子类的静态方法覆盖。
特有属性随着对象存储于堆内存中，而static修饰后的属性，存在于方法区.
什么时候使用静态修饰符？
当对象中出现共享数据时，使用静态修饰。
但对象内的特有数据要定义成非静态存在于堆内存中。
而对于方法时：
当功能内部没有访问到非静态数据时，（即对象的特有数据）
那么可以使用静态修饰。
静态代码块：
用于给类做初始化的。不管有没有对象都执行，只要调用了类里面成员或方法，就会执行，而且优先于主函数，优先执行级别最高。

例：
class JingTai
{
static int age;
static String name;
static//静态代码块初始化类的，所以最先运行。
{
System.out.println("name="+name);

}
//下面是构造代码块，第二个运行
{
System.out.println("age="+age);
}
public static void jing(int x)//被对象调用，第三个运行。
{
x =age+1;//因为age是静态的，所以能调用
System.out.println("x="+x);
}
}
class FaDa
{
public static void main(String[] args)
{
JingTai p =new JingTai();
p.jing(2);
}

}

文档注释：
文档注释有编译工具进行，具体一个要注意的地方是：类名前必须要有public修饰。要编译的方法名必须有public 修饰
javadoc注释标签语法
@author 对类的说明标明开发该类模块的作者
@version 对类的说明标明该类模块的版本
@see 对类、属性、方法的说明 参考转向，也就是相关主题
@param 对方法的说明对方法中某参数的说明
@return 对方法的说明 对方法返回值的说明
@exception 对方法的说明 对方法可能抛出的异常进行说明

命令是：javadoc -d 存放目录名称 -author -version 类名.java

/**
这是一个静态修饰符static的应用说明
@author 李四
@version V1.1
*/
/**
这是一个测试类
*/
public class JingTai
{
/**
空参数构造函数
*/
/**
age 一个整数型变量
*/
public static int age;
/**
name 一个字符串型变量
*/
public static String name;
static
{
System.out.println("name="+name);

}
{
System.out.println("age="+age);
}
/**
打印x的值
@param x 接收一个int型整数
*/
public static void jing(int x)
{
x =age+1;
System.out.println("x="+x);
}
}
注意：main方法作为程序入口，应该在public的类Test中定义

设计模式：

做一个模式，使其能解决一类问题，这样，碰到类似的问题，直接套就可以了。
java中23种设计模式：
举例：
单例设计模式：解决一个类在内存只存在一个对象。不再新生成。
思路：
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
步骤：
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。
两种方式：
饿汉式
class Er
{
private Er(){};
private static Er e =new Er();
public static Er getEr()
{
return e;
}
}
懒汉式
class Er
{
private Er(){};
private static Er e =null;
public static Er getEr()
{
if(e==null)
e=new Er();
return e;
}
}

虽然懒汉式可以延迟加载对象，但为代码的简洁性和安全性，日常用的还是饿汉式。

继承

继承就是将两个类的共性描述提取出来，单独进行描述，从而简化代码，提高复用性。
格式：class 子类名 extends 父类名
关健字为extends ：继承
判断两个类是否有所属关系，那么我们就继承一下，看父类所具有的内容属性，子类是否全都需要具备。如果是，那么他们所属关系成立，就是继承。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。
例如：
class A
{
//void demo1(){}
void demo2(){}
}

class B
{
//void demo1(){}
void demo3(){}
}
我们可以让B继承下A，但发现，A中还具有demo2这个方法是B所不具备的，所以他们俩的继承关系不成立，但我们可以把两个类的共性提取出来，成为一个
class C
{
void demo1(){}

}
那么A和B就能够继承C，这样就实现在代码的简化和复用。

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。

java支持多层继承。也就是一个继承体系

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

聚集：has a
事物与事物的另一种关系，比如（类与类，对象与对象）

聚合:例如：一个班里的有很多学生，那么班级和学生就是聚合关系。就是包含。

组合：组合与聚合区别在于，组合各成员是不可分割的，否则会缺少功能，但聚合里的成员可以脱离，对整体没有影响。

子父类出现后，类成员的特点：

类中成员：
1，变量。
2，函数。
3，构造函数。

1,变量
如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。
例如：
class Fu
{
int num = 4;
}

class Zi extends Fu
{
int num = 5;
void show()
{
System.out.println(super.num);
//有super对象调用函数打印结果是4，没有打印结果是5
}
}

子父类中的函数另一个特性：函数的重写(覆盖)

当子类继承父类，沿袭了父类的功能，这时不但可以保留父类的功能定义，还可以重写功能内容。

覆盖要注意的关健点：
1，子类覆盖父类，必须保证子类访问权限大于等于父类权限，才可以覆盖，否则编译失败。
（权限修饰符没设的时候为默认权限，介于public与private之间。）
例如：
class Fu
{
void show()
{
System.out.println("fu show");
}
}

class Zi extends Fu
{
void show()
{
System.out.println("java");
//这里我即可以改变，也可以增加。增加时我们不用重写一遍父类函数的内容，只虽要super.函数名（）就可以。
}
2，静态只能覆盖静态。

注意：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。

子父类中的构造函数之特点：
子类中的构造函数会默认调用父类中的函数中的默认构造函数，因为子类的构造函数默认第一行有一条隐式的语句 super();
但有几个地方要注意：

例：
class Fu
{
Fu()
注意：如果没有这一个空参数的构造函数，但又有我们指认的非空参数的构造函数，那么我们知道默认那个空参数构造函数也不会生成，这个时候子类就会编译失败。这个时候就不能让子类默认获取super（）；而要指认super（x）
{
num= 60;
System.out.println("fu run");
}
Fu(int x)
{
System.out.println("fu ...."+x);
}

}

class Zi extends Fu
{
Zi()
{
super(); //不管父类有几个构造函数，只要没有指认，那么就默认这一个super();
//super(4);
System.out.println("zi run");
}
Zi(int x)
{
super();
super(3);
System.out.println("zi..."+x);
}
}
调用构造函数用super（）；（括号里面是参数），而调用一般函数用super.函数名（）
一个构造函数中只能要么有this要么有super，而且必须放在第一行
子类中至少会有一个构造函数会访问父类中的构造函数。
extends Object：java中的顶极父类，也就是任何没标明父类的类的默认父类。

final : “最终”修饰符：
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。作用：为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写。
4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。
而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
例如：
final int x=4；那么x永远等于4，不可以被赋值，就成了常量，之所以不直接定常量，是因为要给数值起个名，增强阅读性，以后也好调用。

抽象
修饰符，abstract：只能修饰类和方法：
特点：
1，修饰的类不能创建对象（实例）。
2，修饰的对象只有功能，没有内容。
3，抽象方法和抽象类都必须被abstract关键字修饰，也就是抽象方法一定在抽象类中，
但抽象类不一定要有抽象方法.
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。因为抽象方法和抽象类都必须被abstract关键字修饰（如果只复写了一个，那么子类必然还继承了其它的抽象方法，根据抽象方法必须在抽象类中，则这个类还是个抽象类）。
应用：
1，建立不可创建对象的类。
2，如果子类中需要的方法内容不一样，但又同样都要这么方法，那么就可以创建一个抽象类。
例如：创建一个学校成员，有学生，有老师，都有姓名，年龄，都要上课，但老师上课是教学，学生上课是学习。所以可以这样写：
class XueXiao
{
private String name;
private int age；
XueXiao(String name,int age)
{
this.name = name;
this.age = age;
}
public abstract void work();//子类需要这个功能，但内容不一样，所以用抽象。
}

class Student extends Employee
{
Student(String name,int age)
{
super(name,age);//直接调用父类构造函数。
}
public void work()
{
System.out.println("shangke");
}
}

class LaoShi extends Employee
{
LaoShi(String name,int age)
{
super(name,age);//直接调用父类构造函数。
}
public void work()
{
System.out.println("laoshi");
}
}

模版方法设计模式：

什么是模版方法呢？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去。由该类的子类去完成。

abstract class GetTime
{
public final void getTime()//这个类是不需要改变的，所以就用final最终修饰。
{
long start = System.currentTimeMillis();

runcode();

long end = System.currentTimeMillis();

System.out.println("毫秒："+(end-start));
}
public abstract void runcode();//这个函数主体要设成不确定，这样记算任何函数的运行时间：我只要把要算的函数定义成这个的内容就行了。所以设成抽象类的方法。

}

class SubTime extends GetTime
{

public void runcode()
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
要调用计时这个功能，我们就在要在类中新健一个SubTime的对象。再调用getTime函数的就可以（SubTime类继承了父类，所以有getTime函数。）

接口：
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
关健字：interface 用于定义接口。

接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符，（不写也会自动生成）。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
否则子类是一个抽象类。原因和抽象类一样，有抽象则为抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
1，类可以实现多个接口，用关健字：implements 如：
class Test implements JieKou,JieKou2
2，类继承后，仍可以实现多个接口，如：
class Test extends Demo implements JieKou,JieKou2
3，接口在可以实现多继承,如：
interface Test extends A,B
例：
abstract class Student
{
abstract void study();学生都要学习，所以可以作为父类来给子类继承。
}

interface Smoking
{
void smoke();//抽烟不是所有学生都会，所以，不可以继承，不然所有学生都抽烟了，所以定义为接口，让需要的类实现就行。
}

class ZhangSan extends Student implements Smoking
//继承后再实现，这样就实现了功能的扩展。
{
void study(){}
public void smoke(){}//记得要复写,因为父类是抽象的。
}
class Lisi extends Student
{
void study()
{
System.out.prtintln("study")
}
}

多态：
1，多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2，多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。

3，多态的好处
多态的出现大大的提高程序的扩展性。

4，多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员。
如何要访问子类特有对象必须强制转换为子类对象。

abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
多态还有一个前提：存在覆盖。不然没有意义，只是继承了一个空方法。
{
System.out.println("吃鱼");
}
public void catchMouse()
但是只能使用父类的引用访问父类中的成员。因为父类中并没有catchMouse方法，所以多态无法实现catchMouse

{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
}
public static void function(Animal a)//Animal a = new Cat();父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。
前题：必须是类与类之间有关系。要么继承，要么实现。Animal是动物，Cat是它的子类。
{
a.eat();
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Dog());提高了扩展性，不用再去新建一个对象，再引用对象的功能。
}

Object类:
是所有对象的直接后者间接父类.
该类中定义的是所有对象都具备的功能。
如果自定义类中需要的功能是Object含有的，那么没有必要重新定义，只要沿袭父类中的功能，建立自己特有比较内容，覆盖即可。
常用的有比较功能：
public boolean equals(Object obj)
//这里要是Object对象，所以这里相当于：Object obj =new 自定义类（）
｛
......这里写其自定义的内容，如果这里要有自定义类里的特有功能，那么要强转对象
格式是：自定义类 x = （自定义类）obj；
｝
内部类
特点：1，内部类可以直接访问外部类中的成员，包括私有。
（原因：内部类中持有了一个外部类的引用，格式：外部类名.this）
2，外部类要访问内部类，必须建立内部类对象。
3, 当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，新建立一个对象直接访问static内部类的非静态成员，但对象前
用外类名修饰
new Outer.Inner().function()
在外部其他类中，直接用类名来直接访问static内部类的静态成员，但类名前用外
类修饰
Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。
何时应用内部类：
当描述事物时，事物的内部还有事物，该事物用内部类来描述。这个主要体 现一种类的优化思想。而且一般将内部类私有，而通过创建方法给外部调用。

例如：

class Outer
{
private int x = 3;要访问这个是：Outer.this.x

class Inner//内部类
{
int x = 4;;//要访问这个是：this.x
void function()
{
int x = 6;;//如果不修饰则默认访问方法内的成员。
System.out.println("innner :"+Outer.this.x);
}
}
void method()外部类要访问内部类成员就要新建一个内部类对象。
{
Inner in = new Inner();
in.function();
}
}

class InnerClassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();//
out.method();
//直接访问内部类中的成员就必须修饰引用。以下是格式：
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
// Outer.Inner in = new Outer().new Inner();
// in.function();
}
}
当内部类定义在局部时：
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
例如：
class Outer
{
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}

new Inner().function();

}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);
out.method(8);
//注意：这里之所以可以，是因为out.method(7);进的是栈内存，用完后就自动消失了，out.method(8);又重新加载了，所以尽管变量被final修饰但是依然可以。
}
}

匿名内部类:
特点：
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
应用举例：
interface Inter
{
void method();
}

class Test
{
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("method run");
}
};

}
}
class InnerClassTest