黑马程序员——面对对象

幻风成梦

于 2015-02-02 17:59:36 发布

阅读量388

点赞数

分类专栏： java学习笔记

本文链接：https://blog.csdn.net/bxy19921025/article/details/43411933

版权

java学习笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面对对象编程
概述
面对对象编程（Object Oriented Programming 简称OOP）描述的是对象之间的相互作用。
面向对象编程与面向过程编程懂得区别
1.过程化程序设计先确定算法，再确定数据结构；面向对象编程先确定数据结构，在确定运算。
2.面向过程编程的程序员，习惯于建立数据结构存放数据并定义方法（函数）来操作数据；面向对象编程的程序员则构造一个对象模型，将数据与方法组织在一起。
类和对象：类是对象的抽象，而对象是类的实例；对象都有属性和行为的两大要素，属性是对对象的静态描述而行为则体现了对象的功能和行为，一个类的使用是通过该类实例化来完成。
面对对象的特征：封装、继承、多态
1.封装：把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

封装的好处：

1.可以隐藏想要隐藏的信息。

2.简单化操作。

3.提高重用性。

4.将变化隔离。

示例代码：

package ObjectDemo;
/**封装人对象，把人的年龄、姓名用private私有化，提供方法以便于访问这两个属性，保证了属性的安全。
 * 类中无构造函数时，会调用默认的空参数构造函数可以用构造函数就对对象的属性进行初始化，在对象建立的
 * 时候就运行，只运行一次。
 * 方法是在对象建立以后，调用才运行，对象可以多次调用。
 * 构造代码块：给对象进行初始化
 * 对象一建立就运行，而且优先于构造函数执行。
 * 构造函数和构造代码的区别：
 * 构造代码块是给所有的对象进行初始化。
 * 构造函数是给对应的对象初始化。
 * this：是所在的函数所属对象的引用，只能定义在构造函数的第一行。
 * */
class Person
{
    private int age; //把属性年龄私有化。
    private String name; //把属性名字私有化。
    //构造代码块
    {
        System.out.println("Person run!");
    }
    public Person() //系统默认构造函数。
    {
        
    }
    public Person(String name, int age) //自定义可以初始化的构造函数。
    {
        this.name = name;
        this.age = age;
    }
    public String getName() //获取属性名字。
    {
        return this.name;
    }
    public int getAge() //获取属性年龄。
    {
        return this.age;
    }
    public void setName(String name) //改变属性姓名。
    {
        this.name = name;
    }
    public void setAge(int age) //改变属性年龄。
    {
        if(age>0 && age<140)
        {
            this.age = age;
        }
        
    }
}
public class encapsulation
{
    public static void main(String[] args)
    {
        Person p = new Person("张三",19);
        p.setAge(20);
        p.setName("李四");
        Person p1 = new Person();
        p1.setAge(10);
        p1.setName("王五");
        System.out.println(p.getName()+"--"+p.getAge());
        System.out.println(p1.getName()+"--"+p1.getAge());
    }
}

2.继承： 继承实际上是存在于面向对象程序中的两个类之间的一种关系。当一个类拥有另一个类的所有数据和操作时，就称这两个类之间具有继承关系,private属性除外。被继承的类称为父类(parent class)或超类(super class)，继承了父类的所有数据和操作的类称为子类。
继承的好处：
2.1继承允许代码重用。
2.2扩展新功能适应新情况。
继承类型：
1.单继承：单重继承是指任何一个类都只有一个单一的父类；多重继承是指一个类可以有一个以上的父类。。
2.多重继承：支持多重继承的程序，其结构为复杂的网状，能更自然地模拟现实世界，但设计、实现都比较复杂。
继承特点：

1.子类继承父类的属性（变量）、功能（方法），子类中只需声明特有的东西。
2.带private修饰符的属性、方法是不能被继承的。
3.带protected修饰符的属性、方法是被继承的。
4.构造方法不能被继承，但子类构造方法可以用super()方法调用父类的构造方法，而且super语句必须放在子类构造方法的第一行。

继承格式：
[类的修饰符] class<子类名> extends<父类名>
{
<域定义>；
<方法定义>；
}
示例代码：

package ObjectDemo;
/**
 * 创建Person类、Perman类、PerWoman类，Perman类、PerWoman类继承Person类，继承了Person类的所有方法，
 * 而Perman类、PerWoman类都有歌独特的方法。男人和女人都是人，人共有的特性吃、穿，而男人、女人又有其独特的特性方法。
 * 继承就是对象之间的一种包含关系，父类包含子类，子类持有父类的方法和属性。
 * */
class Person
{
    private String name;
    private int age;
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    public void speak()
    {
        System.out.println("hello world!");
    }
    public void eat()
    {
        System.out.println("吃饭！");
    }
}
class PerMan extends Person
{
    public PerMan(String name, int age)
    {
        super(name, age);
    }
    public void playball()
    {
        System.out.println("打篮球！");
    }
    public void work()
    {
        System.out.println("工作！");
    }
}
class PerWoman extends Person
{
    public PerWoman(String name, int age)
    {
        super(name, age);
    }
    public void son()
    {
        System.out.println("生小孩！");
    }
    public void cook()
    {
        System.out.println("做饭！");
    }
}
public class extend
{
    public static void main(String[] args)
    {
        PerMan pm = new PerMan("李四", 20);
        PerWoman pw = new PerWoman("李玲", 19);
        pm.eat();
        pm.speak();
        pm.playball();
        pm.work();
        pw.eat();
        pw.speak();
        pw.son();
        pw.cook();
    }
}

3.多态：使用父类对象的地方都可以使用子类的对象，这就是所谓的多态。
多态特点

1子类对象可以视作是一个父类的对象。
2父类对象不能被当做一个子类对象。
3如果一个方法的形参是父类对象，调用这个方法时可以使用子类的对象作为实际参数。
4如果父类对象指向的实际上确实是一个子类对象，那么这个父类对象可以用强制类型转换成子类对象的引用。

多态前提
1.类与类（或接口）要有继承关系。
2.一定要有方法重写。
3.一定要有父类或者接口的引用执行子类对象。
多态好处和弊端

好处：提高了程序的扩展性。

弊端：不能使用子类特有的属性和行为。

示例代码：

package ObjectDemo;
/**多态
 * 父类指引指向子类对象，父类指引调用的方法是所指的子类对象覆盖的父类的相对应方法。
 * 多态成员特点
 * 成员变量：编译运行都看父类。
 * 非静态方法：编译看父类，运行看子类。
 * 静态方法：编译、运行都看父类。
 * 向上转型，向下转型，变化的都是父类指引指向的子类对象，不是把父类转换为子类。
 **/
abstract class animal
{
    public abstract void eat();
    public abstract void animaldo();
}
class dog extends animal
{
    public void eat()
    {
        System.out.println("吃骨头！");
    }
    public void animaldo()
    {
        System.out.println("看家！");
    }
}
class cat extends animal
{
    public void eat()
    {
        System.out.println("吃鱼！");
    }
    public void animaldo()
    {
        System.out.println("抓老鼠！");
    }
    
}
public class polyDemo
{
    public static void fun(animal a)
    {
        a.eat();
        a.animaldo();
    }
    public static void main(String[] args)
    {
        animal d = new dog();
        animal c = new cat();  //向上转型。
        fun(d);
        fun(c);
        dog Dog = (dog)d;
        cat Cat = (cat)c;  //向下转型。
        fun(Dog);
        fun(Cat);
    }
}

4.抽象类

1.抽象方法必须用abstract来修饰，它只有原型没有方法体(花括号也没有)。
2.一个包含抽象方法的类必须声明为抽象类；抽象类的方法必须被子类覆盖所有的抽象方法后才能被实例化，否则这个子类还是一个抽象类。
3.抽象类必须用abstract关键字来修饰。
4.抽象类不能被实例化，也就是不能用new关键字去产生对象。
5.抽象类的方法定义为protected，因为它只被子类使用，创建一个具体子类的实例时，它的父类构造方法被调用以初始化父类中定义的数据域。
6.可以定义不包含抽象方法的抽象类，而且即使父类是具体的，其子类也可以是抽象的。
7.抽象类可以用作一种数据类型定义对象数组（可以用于得到具体子类的实例的引用）。

抽象类成员特点

成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)

成员方法：抽象类中分为两种方法， * 一种是抽象方法，这种方法在子类中必须要被实现。 * 一种是普通的方法。可以被子类直接继承使用。

构造方法：有构造方法，为子类实例化的时候使用。

抽象类注意事项

1.abstract 不能于final并列修饰同一个类。
2.abstract不能与private,static,final并列修饰同一方法。
3.abstract 方法必须位于 abstract 类中。
4.abstract类中可以不包含 abstract 方法。
5.abstract类不能实例化，但抽象类可以有构造函数。

抽象类的优点
抽象类是它的子类的所有公共属性的集合，提高程序开发和维护的效率，把这些各类的公共属性从他们各自的类的定义中抽取出来形成一个抽象类的组织方法，显然比把公共属性保留在具体类中的方法要方便得多。
示例代码：

package ObjectDemo;
/**抽象
 * 抽象类：把一个对象的所有子类都有行为或者属性，抽取出来单独封装成成一个类。
 * 子类继承了抽象类，也就继承了抽象类中的那些共有的属性和行为。
 * */
abstract class student
{
    public abstract void study();
    public abstract void eat();
}
class minStudent extends student
{
    public void study()
    {
        System.out.println("学习");
    }
    public  void eat()
    {
        System.out.println("吃饭");
    }
}
public class Stuent
{
    public static void main(String[] args)
    {
        minStudent stu = new minStudent();
        stu.eat();
        stu.study();
    }
}

5.接口：接口是一种与类相似的结构，只包含常量和抽象方法，可看作是一种特殊的抽象类。其目的是指明多个对象的共同行为，如果抽象类所有的方法都是抽象的，就可以用接口来实现。
特点
1.让类不必受限于单一继承的关系，而可以灵活的同时继承一些共有特性，从而达到多重继承目的。
2.接口可以继承，而且可以多重继承。
接口定义
定义格式
public interface 接口名
{
方法
}
1.接口中的变量都是常量，默认都是public static final。
2.接口中的方法都是抽象方法，默认都是public abstract。
接口实现

1.implements关键字去实现一个接口中的所有方法。
2.一个类可以在继承一个父类的同时，实现一个或多个接口。

接口和抽象类的区别

1.抽象类只能被单继承；接口可以被多实现。
2.
抽象类的成员：
成员变量：可以是常量，也可以是变量。
成员方法：可以是抽象，也可以是非抽象。
构造方法：不可以创建对象，但是可以给子类实例化使用。
接口的成员
成员变量：只能是常量。默认用public static final修饰。
成员方法：只能是抽象的。默认用public abstract修饰。
3.抽象类中定义的是体系结构中的共性的内容。接口中定义的是对象的扩展功能。

示例代码：

package ObjectDemo;
/**
 * 接口：就是把一个对象所特有的属性或行为封装接口，提供给拥有这个特有属性或行为的对象是实现。
 * 接口与类可以单实现，也可以多实现。
 * 接口与接口可以单继承也可以多继承。
 * 定义一个打篮球的学生接口
 * */
abstract class Students
{
    public void study()
    {
        System.out.println("学习");
    }
    public void eat()
    {
        System.out.println("吃饭");
    }
}
interface PlayBall
{
    public abstract void PlayBasketBall();
}
class PlayBasketStu  extends Students implements PlayBall
{
    
    public void PlayBasketBall()
    {
        System.out.println("打篮球");
    }
}
public class PlayBasketBall
{
    public static void main(String[] args)
    {
        PlayBasketStu stu = new PlayBasketStu();
        stu.eat();
        stu.study();
        stu.PlayBasketBall();
    }
}