Java面相对象（一）

面向对象

面向对象的基本思想是，从现实世界中客观存在的事物发出来构造软件系统，并在系统构造中尽可能运用人类的自然思维方式。

在面向对象编程中，我们有两个重要的概念：1.类，2.对象

什么是类?
属性（成员变量）：成员变量又称为成员属性，它是描述对象状态的数据，是类中很重要的组成成分。
属性代表类有什么。
类型 标识符 【= 初值】

方法：类的成员，在花括号中编写执行的代码，它是类能够执行的功能实现。

方法代表类能干什么。

作用域 修饰符 返回类型 标识符(形式参数){方法体 ； return 返回值 }

引用类型

java语言中除了（8种）基本类型外的类型统称为引用类型。
JAVA中的对象是通过引用对其进行操作的：
String s ;//声明一个引用
s=new String("hello world!");//设置引用指向的对象
内存的使用：
类是静态的概念，存放在代码区。
对象是new出来的，存在堆中。类中的成员变量在不同的对象中有不同的值（除了静态变量）。而方法只有一份，在调用时，才消耗内存。
对象的创建和使用
必须使用new创建对象。//列如：Person[类名]  person[标识符] = new Person()[构造器];
使用引用+“．”来调用对象中的属性和方法。
同一个类的每个对象有不同的成员变量存储空间。
方法中的参数：引用传递和值传递。
其实JAVA中只含有值传递，并没有所谓的引用传递。
当然也是由于java没有所谓C++的引用。JAVA的引用与C++的指针更为类似，而不是引用。当然C++中引用和指针本来也比较类似...所以...他们都很类似，容易混淆
构造函数（构造器）：


构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

继承（extends）

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
列如：继承从我们生活中理解，我们继承了我们父母的东西（血型），而我们自己身上也具有自己的东西；而在java语言中是为代码的复用从而减少工作量。
public class Animal {
//属性
String name;
String yuMao;
String yuMaoColor;
int  weight;
//构造器
public Animal(){

}
public Animal(String name,String yuMao,String yuMaoColor,int weight){
this.name=name;
this.yuMao=yuMao;
this.yuMaoColor=yuMaoColor;
this.weight=weight;
}
//方法
//吃
public void eat(){

System.out.println("吃东西。。。");
}
//跑
public void  run(){

System.out.println("四条腿跑。。。");
}
//叫
public void bellow(){

System.out.println("叫叫叫。。。");
}

}

public class Cat extends Animal{
//空构造器
public Cat(){
}
public Cat(String name,String yuMao,String yuMaoColor,int weight){
super(name,yuMao,yuMaoColor,weight);
}
//吃
public void eat(){
super.eat();
System.out.println("吃老鼠。。。");
}
//叫
public void bellow(){
System.out.println("喵喵喵。。。");
}
}

访问控制修饰词：

当前我们写的代码中，无论是方法和变量的访问都是不受限制的，当有恶意代码进入时，我们的程序将不抗一击，所以我们需要对变量与方法甚至是类的访问惊醒控制。
java中有4个级别的访问控制：
1.公开：使用public关键字修饰。表示对外公开。
2.保护：使用protected关键字修饰。向子类与同一包下的类公开。
3.默认(default)：没有访问关键字。向同一包中的类公开。
4.私有：使用private关键字修饰。表示完全不公开。


访问修饰符特点

访问级别仅仅适用于类及类得成员，而不适用于局部变量，局部变量只能在方法内部被使用访问。根本也不需要访问修饰符修饰。

TIPS:修饰类，只能使用public ， abstract ,  final .

         修饰方法，可以使用public ， protected，(default)默认, private

         修饰属性，可以使用public，protected，(default)默认，private

抽象 abstract

abstract修饰符可用来修饰类和成员方法。
1.使用abstract修饰类表示此类为抽象类。抽象类用于不允许被实例化的类（就是不能产生对象。）
2.使用abstract修饰方法表示此方法为抽象方法。抽象方法与正常方法（具体方法）区别就在于抽象方法没有方法的实现即没有方法体。

抽象的规则

1.抽象类可以没有抽象方法，但是有抽象方法的类必须被定义为抽象类。
2.没有抽象构造方法，抽象类的构造器也是正常的。
3.抽象类可以含有具体方法。

final修饰词

final就是不可改变，他可以修饰非抽象类，非抽象方法和变量。
1.final修饰的类，将不再能被继承。
2.final修饰的方法，将不再能被子类重写。
3.final修饰的变量必须赋值，且不能再改变。也就是成为我们常说的常量。

static修饰词

static修饰词，可以用来修饰成员变量（类的属性），成员方法（类的方法）和代码块。
1.通过static修饰的成员变量和方法，将变为静态（从属与类），不再属于某个对象，将可以直接使用类名.属性名/方法名（）;的方式来调用。 
2.通过static修饰代码块，这块代码将在jvm虚拟机加载该类时，调用。比构造器的调用都早。

static特点：
1.被static修饰的变量将在整个程序中只有一份。
2.被static修饰的方法不需要通过所属类的实例（对象）来调用，所以在静态方法中，不能使用this，也不能访问此类的非静态方法与非静态变量。

接口（interfaec）

在JAVA中接口的意思有两个：

1.概念性的接口，即指系统对外提供的服务。类的所有能被外部访问的方法就构成了类的接口。
2.指用interface关键字修饰的一种类型：接口类型。他用于描述一系列功能性的方法，并让子类实现。


接口的成员：

1.静态常量，接口不能拥有一般的属性，只能拥有被public,static和final修饰的变量，即静态常量。
2.抽象方法，接口只能拥有抽象方法，不能有具体方法。
3.不能拥有构造函数，所以接口类型不能直接创建对象。

抽象类与接口

相同点：

1.处于继承上层的抽象类型，这样可以提高系统间的松耦合。
（父类引用指向子类对象）
2.他们都不能被实例化（不能直接创建他们的对象）
3.都可以定义抽象方法，定义抽象方法可以描述我们的系统需要的，但又不必操心他的具体实现。


抽象类与接口的区别：

1.抽象类可以有具体方法，从而避免子类重复实现，提高了代码的重用率。而接口只能添加抽象方法，一旦接口被发布，我们就一定要保证他是稳定的，否则我们一修改接口，那么我们就必须修改所有的子类。(抽象类的优势)
2.一个子类只能继承一个父类，但是他却可以实现多个接口。(接口的优势)


内部类：

在一个类的内部定义的类成为内部类。内部类允许把一些逻辑相关的类组织在一起。为了叙述方便，我们就把最外层的类称为顶层类，内部的类叫内部类。

内部类分为一下几种：
成员内部类，局部内部类，匿名内部类


成员内部类：

定义在类的内部，与成员变量与方法在同一层。

class OutClass{

class InnerClass {

public void mTest(){}

}

}

想要使用这个内部类，我们可以使用下面的方式获取成员内部类的对象：

OutClass.InnerClass inner = new OutClass().new InnerClass

成员内部类

1.成员内部类可以直接访问外部类的所有成员，由于内部类是在外部类之中的，所以外部类各个访问级别的成员都是可以访问到的。
2.成员内部类中还能拥有自己的成员内部类，最里面的内部类能访问到所有外部类的成员。
3.外部类不能直接访问内部类的成员，必须创建内部类的对象，才能访问到。
4.成员内部类中不能定义静态变量和静态方法。
5.在内部类中如有与外部类由相同名字的变量需要使用外部类名.this.变量名的方式访问。


对于顶层类，只能使用public和default两种访问控制符。

不过内部类与方法，属性在一层，所以他们也可以使用访问控制符：
public，protected，（default），private。


静态内部类：

除了使用访问控制符限定成员内部类以外，我们还能使用static修饰我们的内部类。

class OutterClass{

static class InnerClass{


}

}

要创建静态内部类的对象：

OutterClass.InnerClass inner = new OutterClass.InnerClass() ;

静态内部类

1.静态内部类可以直接访问外部类的静态成员。
2.静态内部类中可以有静态成员也可以有实例成员。
3.静态内部类中的静态成员可以直接使用外部类名.内部类名.静态成员的方式调用。

局部内部类：

定义在方法中

public void outFunc(){

class InnerClass{

public void test(){

}
}

new InnerClass().test() ;

}

局部内部类

1.局部内部类只能在定义的方法内使用。
2.局部内部类不能包含静态成员。
3.局部内部类必须在定义后使用。
4.局部内部类与局部变量一样不能使用访问控制符。
5.局部内部类可以访问类中的所有成员。

匿名内部类：

匿名内部类是一种特殊的内部类，他在定义的同时创建对象，他需要父类或者父接口来帮助定义。
new SuperClass(){
实现父类的抽象方法....
}

匿名内部类特点：

1.匿名内部类没有构造函数，但是他会调用父类的构造函数
2.在匿名内部类中使用外部类的局部变量，必须保证局部变量被初始化，也就是使用final关键字修饰。
3.定义匿名内部类的同时会获取到匿名内部类的对象。