黑马程序员——JAVA中的面向对象

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1.对象和类的概念

在程序中操作对象是类的一个实例。

创建一个对象：Hello obj=new Hello();

调用方法：obj.showString()

类是对象的实例化，相当于一个模板

2.比较面向过程的思想和面向对象的思想

面向过程的思想：由过程、步骤、函数组成，以过程为核心；

面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。

面向过程是先有算法，后有数据结构。

面向对象是先有数据结构，然后再有算法。

3.面向对象（class）

public class AnimalText {

public void eat(){

System.out.println("吃饭");

}

public static void main(String[] args) {

Text t=new Text();

t.eat();

Dog dog=new Dog();

Dog dog1=new Dog("汪汪");

}

}

class Dog{

String say;

Dog(){

System.out.println("狗吃骨头");

}

Dog(String say){

this();

this.say=say;

System.out.print("狗还会叫"+say);

}

}

（一）引用的概念

通过new一个对象，根据这个对象调用对象里的方法的行为叫引用；

如： Text t=new Text();

t.eat();

（二）构造方法的概念

构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。

注意：构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。

构造方法没有返回值。格式为：public 方法名。

构造方法的方法名与类名相同。

构造方法是在对象生成的过程中自动调用，不可能利用指令去调用。

在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。

例如：

class Dog{

String say;

Dog(){ //狗的构造方法

System.out.println("狗吃骨头");

}

Dog(String say){

this.say=say;

System.out.print("狗还会叫"+say);

}

}

4.方法重载

构造方法重载

在类中可以构造多个构造方法，但多个构造方法的参数表一定不同，参数顺序不同即属于不同的构造方法：即重载

Dog(){ //狗的构造方法

System.out.println("狗吃骨头");

}

Dog(String say){

this.say=say;

System.out.print("狗还会叫"+say);

}

如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。

5.this

在构造方法中，this表示本类的其他构造方法：

class Dog{

String say;

Dog(){ //构造方法Dog

System.out.println("狗吃骨头");

}

Dog(String say){

this(); // this代表是Dog（）的方法

this.say=say;

System.out.print("狗还会叫"+say);

}

}

如果调用Dog(String say)则为this(String say)。

特别注意：用this调用其他构造方法时，this必须为第一条语句，然后才是其他语句。

This表示当前对象。

Dog(String say){

this(); // this代表是Dog（）的方法

this.say=say; //表示当前String的say

System.out.print("狗还会叫"+say);

}

此时打印的是实例变量，而非局部变量，即定义在类中而非方法中的变量。

This.say表示实例变量。

谁调用this.say那么谁即为当前(this)对象的Dog方法。

6.封装：

使对象的属性尽可能私有，对象的方法尽可能的公开。用private表示此成员属性为该类的私有属性。

7.面向对象高级： 修饰符：static

在类中，用static声明的成员变量为静态变量，它为该类的公用变量。第一次使用时被初始化，对于所有的类来说，static变量只有一份。用static声明的变量方法为静态变量，在静态方法中不可访问非静态变量。可以通过对象的引用或类名直接访问静态成员。

public class AnimalText {

private static int sid=0;

private String name;

int id;

AnimalText(String name){

this.name=name;

id=sid++;

}

public void info(){

System.out.println(" name "+name+" id "+id);

}

public static void main(String[] args) {

AnimalText.sid=100;

AnimalText animal=new AnimalText("mimi");

AnimalText animal1=new AnimalText("pipi");

animal.info();

animal1.info();

}

}

8.private default protected public

private ：本类访问；

default ：表示默认，不仅本类访问，而且是同包可见。

Protected：同包可见+不同包的子类可见

Public ：表示所有的地方均可见

9.extends(继承)

父类的非私有化属性和方法可以默认继承到子类。

Class Son extends Father{

}

如果父类中的私有方法被子类调用的话，则编译报错。

父类的构造方法子类不可以继承，更不存在覆盖的问题。（非构造方法可以）

如果子类访问父类的构造方法，则在编译的时候提示访问不到该方法。

JAVA中不允许多继承，一个类有且只有一个父类（单继承）。

JAVA的数据结构为树型结构，而非网状。（JAVA通过接口和内部类实现多继承）

10.overwrite（重写）

子类可以根据需要重写父类的方法，，重写时方法名一定相同，且不能使用比被重写又更严格的限制；

public abstract class Text {

public static void main(String[] args) {

monkey m=new monkey("香蕉");

goalmonkey gm=new goalmonkey("香蕉 ","金色");

gm.eating();

}

}

class monkey{

String eat;

monkey(String eat){

this.eat=eat;

}

public void eating(){

System.out.print(eat);

}

}

class goalmonkey extends monkey{

String eat;

String furcolor;

goalmonkey(String eat,String furcolor){

super(eat);

this.eat=eat;

this.furcolor=furcolor;

}

public void eating(){ //重写父类eating方法

System.out.print("吃："+eat+" 毛色："+furcolor);

}

}

11.final

final可以修饰类、属性、方法。

当用final修饰类的时候，此类不可被继承，即final类没有子类。这样可以用final保证用户调用时动作的一致性，可以防止子类覆盖情况的发生。

当利用final修饰一个属性（变量）的时候，此时的属性成为常量。

JAVA利用final定义常量（注意在JAVA命名规范中常量需要全部字母都大写）：

Final int AGE=10；

常量的地址不可改变，但在地址中保存的值（即对象的属性）是可以改变的。

Final可以配合static使用。

public class Text {

static final int id=100;

public static void main(String[] args) {

System.out.print(Text.id);

}

}

在JAVA中利用public static final的组合方式对常量进行标识（固定格式）对于在构造方法中利用final进行赋值的时候，此时在构造之前系统设置的默认值相对于构造方法失效。

常量（这里的常量指的是实例常量：即成员变量）赋值：

①在初始化的时候通过显式声明赋值。Final int x=3；

②在构造的时候赋值。

局部变量可以随时赋值。

利用final定义方法：这样的方法为一个不可覆盖的方法。

Public final void print(){}；

为了保证方法的一致性（即不被改变），可将方法用final定义。如果在父类中有final定义的方法，那么在子类中继承同一个方法。

如果一个方法前有修饰词private或static，则系统会自动在前面加上final。即private和static方法默认均为final方法。

注：final并不涉及继承，继承取决于类的修饰符是否为private、default、protected还是public。也就是说，是否继承取决于这个方法对于子类是否可见。

12.object

如果在类的声明中没有使用关键字extends指明基类，则默认基类为object类，即父类；object类中代表： toString 、 equals

(1)toString():是利用字符串来表示对象。

当我们直接打印定义的对象的时候，隐含的是打印toString()的返回值。

可以通过子类作为一个toString()来覆盖父类的toString()。

以取得我们想得到的表现形式，即当我们想利用一个自定义的方式描述对象的时候，我们应该覆盖toString()。

(2)equal

两个对象的实例化虽然相同但是它的内存地址不同，所以要调用equals方法，同时也要重写equals方法；

如下例子：

public class Text {

public static void main(String[] args) {

Cat c1=new Cat("bule",22,12);

Cat c2=new Cat("bule",22,12);

System.out.println(c1.equals(c2));

}

}

class Cat{

String color;

int height;

int weight;

public Cat(String colo,int height,int weight){

this.color=color;

this.height=height;

this.weight=weight;

}

public boolean equals(Object obj){//重写equals方法

if(obj==null) return false;

else

{

if(obj instanceof Cat){

Cat c=(Cat)obj;//强制转换

if(c.color==this.color && c.height==this.height && c.weight==this.weight){

return true;

}

}

}

return false;

}

}

13 Abstract(抽象类)

如果将一个类设置为abstract，则此类必须被继承使用，此类不可生成对象，必须被继承使用。

Abstract可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。

Abstract虽然不能生成对象，但是可以声明，作为编译时类型，但不能作为运行时类型。

Final和abstract永远不会同时出现。

当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。

注意比较：

private void print(){}；此语句表示方法的空实现。

Abstract void print()； 此语句表示方法的抽象，无实现。

如果一个类中有一个抽象方法，那么这个类一定为一个抽象类。

反之，如果一个类为抽象类，那么其中可能有非抽象的方法。

如果让一个非抽象类继承一个含抽象方法的抽象类，则编译时会发生错误。因为当一个非抽象类继承一个抽象方法的时候，本着只有一个类中有一个抽象方法，那么这个类必须为抽象类的原则。这个类必须为抽象类，这与此类为非抽象冲突，所以报错。

所以子类的方法必须覆盖父类的抽象方法。方法才能够起作用。

Abstract和static不能放在一起，否则便会出现错误。（这是因为static不可被覆盖，而abstract为了生效必须被覆盖。）

例：

abstract class Animal {

public abstract void eat(); //定义一个抽象方法

public static void main(String args[]){

cat c=new cat();

c.eat();

}

}

class cat extends Animal{

public void eat(){

System.out.print("cat");//子类中必须重写抽象方法

}

}

14.多态

多态又叫动态绑定，是在执行期间判断所引用的实际类型，根据其类型引用方法；

其中包含：继承、重载、重写；

例子：

public abstract class Text {

public static void main(String[] args) {

Cat c=new Cat("波斯猫");

c.enjoy();

Dog d=new Dog("哈皮狗 ");

d.enjoy();

lady l=new lady("小红 ", c);

l.enjoy();

}

}

abstract class Animal {

String name;

Animal(String name){

this.name=name;

}

public abstract void enjoy();

}

class Dog extends Animal{

Dog(String name) {

super(name);

}

public void enjoy(){

System.out.print("狗叫");

}

}

class Cat extends Animal{

Cat(String name) {

super(name);

}

public void enjoy(){

System.out.print("猫叫");

}

}

class lady{

String name;

Animal pet;

lady(String name,Animal pet){

this.name=name;

this.pet=pet;

}

public void enjoy(){

System.out.print("我的宠物");

}

}

多态使得程序更加灵活；

16.接口

接口是一种特殊的抽象类。

如:

interface IA{

}

public interface：公开接口

与类相似，一个文件只能有一个public接口，且与文件名相同。

在一个文件中不可同时定义一个public接口和一个public类。

一个接口中，所有方法为公开、抽象方法；所有的属性都是公开、静态、常量。

一个类实现一个接口的格式：

class IAImple implements IA{

};

一个类实现接口，相当于它继承一个抽象类。

类必须实现接口中的方法，否则其为一抽象类。

实现中接口和类相同。

接口中可不写public，但在子类中实现接口的过程中public不可省。

（如果剩去public则在编译的时候提示出错：对象无法从接口中实现方法。）

注：

① 一个类除继承另外一个类，还可以实现接口；

class IAImpl extends java.util.Arrylist implement IA{}

继承类 实现接口

这样可以实现变相的多继承。

② 一个类只能继承另外一个类，但是它可以继承多个接口，中间用“，”隔开。

Implements IA,IB

所谓实现一个接口，就是指实现接口中的方法。

③ 接口和接口之间可以定义继承关系，并且接口之间允许实现多继承。

例：interface IC extends IA,IB{};

接口也可以用于定义对象

IA I=new IAImpl();

实现的类从父类和接口继承的都可做运行时类型。

IAImple extends A implement IA,IB

IB I=new IAImple();

I instance of IAImple;

I instance of A;

I instance of IA;

I instance of IB;

返回的结果均为true.

public class AnimalText {

public static void main(String[] args) {

Animal animal=new Dog();

animal.eat();

animal.singer();

}

}

interface Animal{

public void singer();

public void eat();

}

class Dog implements Animal{

@Override

public void singer() {

System.out.print("唱歌");

}

@Override

public void eat() {

System.out.print("吃饭");

}

}

在接口中实现多继承

public class AnimalText {

public static void main(String[] args) {

Animal a=new Dog();//实例化Dog

a.enjoy();

value v=new Dog();

v.valuable();

protect p=(protect)v;//对象转型

p.protectable();

}

}

abstract class Animal{ //定义一个抽象类Animal

public abstract void enjoy() ;

}

interface protect{ //定义一个接口

public void protectable();

}

interface value{

public void valuable();

}

interface hen extends value{ //定义一个继承hen的接口（实现接口对接口）

public void print();

}

class Dog extends Animal implements protect,value{//通过实现多继承

@Override

public void valuable() { // 实现接口

System.out.print("50元");

}

@Override

public void protectable() {// 实现接口

System.out.print("不受保护");

}

public void enjoy(){ //重写抽象方法

System.out.print("动物");

}

}

class Hen implements hen{//实现接口对接口

public void print(){

System.out.print("好吃");

}

public void valuable(){

System.out.print("11");

}

}

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------