面向对象复习

------- android培训、java培训、期待与您交流！
----------

面向对象，继承，多态

面向对象

面向对象相对于面向过程。都是一种思想。过程强调的功能，面向对象是过程封装进对象，强调的是拥有功能的对象。

面向对象使复杂事情简单化，使功能封装，提高了安全性。

—————————

面向对象的三大特征：

封装，继承，多态。

——————

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。

使用方便，隔离了变化，提高了重用性和安全性。

原则：属性都隐藏，提供公共方法访问。不需要对外提供的都隐藏。

private：成员权限修饰符，私有。使成员只在本类中有效。

—————————

继承

多个类中有共有属性和功能，把共有抽取出来，存在一个类中，就是父类，多个类为子类。通过extends关键字联系。

java中只能单继承，可以多层继承，多实现。

——————

子父类中相同变量用this,super分别调用。

相同函数通过复写调用(复写要权限大于等于，静态只能复写静态)。

子类构造函数中必有一个指向父类构造函数。

默认super(),可以自己指定。

—————————

多态

当存在继承或实现关系时，父类的引用指向自己的子类对象。提高了程度的扩展性，但只能使用父类的引用。

通过父类类型建立子类对象，可以把对象强制转成子类类型，以调用子类方法。

多态通过对象实现，编译时看类，运行时看对象。静态相对类存在，编译运行只看类。

—————————

变量分为成员和局部变量

成员变量存在堆内存中，作用于类中，局部变量位于栈内存中作用于定义的函数或语句中。

——————

构造函数

用于对类进行初始化。(没有定义时，系统会默认加个空参数构造函数)

构造代码块:对对象进行共享初始化。优先于构造函数执行。

构造只执行一次，进行初始化。一般函数被对象调用时执行。

——————

this,super

代表所在函数所属对象的引用。

this代表本类对象调用，super代表父类对象调用。

定义类中函数时，函数内部要用到调用该函数的对象时，用this表示。

在构造函数中调用构造函数用法为：this(参数);

static优先于对象存在。因此不能用于静态函数中。

——————

static：成员修饰符，静态。优先于对象存在，对象共享，可以不建立对象，直接类名调用。可以被非静态调用，不能在静态中调用非静态。生命周期最长，随着类存在。存在于方法区中静态方法区中。

静态用于定义共享数据，函数内部没有访问到非静态数据时，可以定义成静态函数。

静态代码块

static{}随着类的加载而执行，只对类进行一次初始化。

——————

final：修饰符，最终。可修饰类，变量，函数。

修饰的类不能被继承，变量修饰成常量，函数不能被复写。

—————————

抽象类，方法，接口

共性抽取出来，由子类实现。abstract标识。抽象类不能建立对象，有抽象方法的一定是抽象类。

接口

interface标识。方法抽象，常量。

因为不能实现，只有公有静态常量和公有抽象方法。

因为没有特有属性，可以多实现，补充了单继承的局限性。

接口是对外暴露的规则，对程序功能进行了扩展，可以多实现，接口之间可以多继承。

—————————

Object类

根类。

equals(Object obj)比较对象是否相等(比较地址值)

toString()返回该对象的字符串表示

—————————

内部类

位于另一个类中。相当于类中变量，有位置上特点和类的特点。因为位于类中，可直接调用外部类中内容。外部类只能对象访问。

位于成员位置时有成员属性，成员静态时，只能访问静态成员。内部类中有静态成员时，内部类必须静态。

局部内部类时不能有变量只能用final修饰。不能访问局部变量只能final修饰的变量

package demo;

/**
* 继承，多态，接口，内部类
* 构造函数，静态，成员。
*/
class Person
{
//成员变量，name,age
private String name;
private int age;
//静态对类进行初始化，静态中只能调用静态成员。静态可以直接类名调用。
public static String country="China";
//静态代码块只在类加载时执行一次
static
{
System.out.println("static代码块");
}
public static void show()
{
System.out.println("country-"+country);
}
//构造函数对对象进行初始化，构造代码块对对象进行共享初始化，
//只在对象建立时执行一次
{
System.out.println("country::="+country);
}
Person()
{
//没有建立构造函数时，系统会默认添加个空参数构造函数
System.out.println("Person()");
}
Person(String name)
{
//this指向对象中的引用
this.name = name;
System.out.println("name="+name);
//非静态函数中可以调用静态成员
System.out.println("country::="+country);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void speak()
{
System.out.println("name:"+name+"age:"+age);
}
public final void per()
{
System.out.println("final");
//final修饰的函数不能被复写
}
}
final class Final//final修饰的类不能被继承
{
Final()
{
System.out.println("final");
}
}

class Student extends Person
{
private int cj;
Student()
{
//子类构造函数中默认有super()指向父类构造函数
System.out.println("Student：：：");
}
Student(String name,int cj)
{
//手动指定父类构造函数
super(name);
this.cj = cj;
System.out.println("cj:::"+cj);
}
public int getCj() {
return cj;
}
public void setCj(int cj) {
this.cj = cj;
}
public void speak()
//子类可以复写父类中方法
{
System.out.println("Student:::"+cj);
}
public void speakStu()
{
System.out.println("Stn");
}
//类中建立的类为内部类
class Xue
{
//成员位置上内部类可以被成员修饰符修饰
private int cj=2;
//
public void show()
{
int cj = 3;
//this调用内部类中对象成员，类名.this.调用外部类对象成员
System.out.println("3sj"+cj+"2cj"+this.cj+"Stu:cj"+Student.this.cj);
//由于内部类位于外部类范围内，可以直接调用外部类中私有属性成员
}
}
static class Xi
{
//当内部类中包涵静态时，内部类必须定义成静态。
//静态内部类中只能调用外部静态成员
public static void show()
{
System.out.println("static内部类");
}

}
public void neng()
{
//匿名内部类，通过继承或实现建立对象
new Study()
{
public void study()
{
//接口或抽象类中方法必须要实现
System.out.println("匿名内部类");
}
}.study();
}

}
interface Study
{
//接口中方法全抽象的
public abstract void study();
}
public class Demo2
{

public static void main(String[] args)
{
Person p = new Person("ppp");
p.setAge(22);
p.speak();
Person p1 = new Student("sss",13);
//父类类型指向子类对象。函数指向子类复写函数
p1.speak();
Student s = (Student)p1;
//子类对象强转成子类类型,可以调用子类特有方法
s.speakStu();
}

}

------- android培训、java培训、期待与您交流！
----------