黑马程序员-java基础-面向对象总结

----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！----

类与对象概述:

* A:我们学习编程是为了什么
* 为了把我们日常生活中实物用学习语言描述出来
* B:我们如何描述现实世界事物
* 属性 就是该事物的描述信息(事物身上的名词)
* 行为 就是该事物能够做什么(事物身上的动词)
* C:Java中最基本的单位是类,Java中用class描述事物也是如此
* 成员变量 就是事物的属性
* 成员方法 就是事物的行为
* D:定义类其实就是定义类的成员(成员变量和成员方法)
* a:成员变量
* b:成员方法
* E:类和对象的概念
* a:类：是一组相关的属性和行为的集合

* b:对象：是该类事物的具体体现

面向对象的概述:

  强调对象的动作方法.调用对象的自身的方法,从执行变成一指挥者;

面向对象开发,设计以及特征:
* A:面向对象开发
* 就是不断的创建对象，使用对象，指挥对象做事情。
* B:面向对象设计
* 其实就是在管理和维护对象之间的关系。
* C:面向对象特征
* 封装(encapsulation)
* 继承(inheritance)
* 多态(polymorphism)


封装:

* A:封装概述
* 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。


* B:封装好处
* 隐藏实现细节，提供公共的访问方式
* 提高了代码的复用性
* 提高安全性。

* C:封装原则
* 将不需要对外提供的内容都隐藏起来。

* 把属性隐藏，提供公共方法对其访问。

  private关键字：是一个权限修饰符.
  可以修饰成员(成员变量和成员方法)
  被private修饰的成员只在本类中才能访问。
  private最常见的应用：
  把成员变量用private修饰
  提供对应的getXxx()/setXxx()方法

   this关键字:

   代表本类的对象引用

   this 区别成员和局部变量重名，this调用本类中的方法 

案例:

class Goddess{

private String name; //姓名
private int age; //年龄

public String getName(){ //getName 获取name的值
return name;
}
public void setName(String name){//setName 给name赋值
this.name = name;
}


public int getAge(){

return age;
}


public void setAge(int age){ 
this.age = age;
}

继承:

* A:概述
* 多个类中的有相同的成员,将他们的共性抽取到一个单独类中,那么多个类中无需在定义成员,可以直接继承那个单独类.

* B:由来
* 共性的抽取;

* C:好处

代码少;

继承的出现使类与类之间产生了关系,导致了(OOP)面向对象的第3个特征多态的诞生;
提高了维护性;

* D:特点
* 支持单继承,一个类,只能直接继承一个类,不允许同时继承多个类;
* 不支持多继承;
* 但是支持多层继承,多重继承;

* E:继承后子类父类中构造方法的特点
* 子类中,构造方法 第一行有一个隐式代码 super()不写有;//super()-调用父类空参数构造方法
* 如果子类中,没有定义过构造方法,编译的时候 自动添加super();
* 子类中,无论重载多少构造方法,第一行都是super();
* 当父类中没有空参构造方法的时候,子类构造方法必须手动写super否则编译失败;

案例:
/*
  老师类与学生类
  老师类， 姓名，年龄
    自己的功能，上课

  学生类，姓名，年龄
    自动的功能，学习
   有重复的成员，面向对象中继承的思想，共性抽取出来，形成一个父类
   让学生类和老师类，共用父类中的成员
*/
class Person
{
private String name;
private int age ;
public void setName(String name){
 this.name = name;
}
public void setAge(int age){
  this.age = age;
}
public String getName(){ return name;}
public int getAge(){ return age;}
}
class Teacher extends Person
{
//打印出，姓名和年龄
public void teacher(){
 System.out.println(getName()+".."+getAge());
}
}
class Student extends Person
{
//打印出，姓名和年龄
public void study(){
  System.out.println(getName()+".."+getAge());
}
}
class ExtendsTest1 
{
public static void main(String[] args) 
{
Teacher t = new Teacher();
t.setName("张三");
t.setAge(20);
t.teacher();


Student s = new Student();
s.setName("张三");
s.setAge(20);
s.study();
//System.out.println("Hello World!");
}
}

多态

* A:多态概述
* 事物存在的多种形态 
* B:多态前提
* a:要有继承关系。
* b:要有方法重写。
* c:要有父类引用指向子类对象。

* A:多态中的成员访问特点
* a:成员变量
* 编译看左边，运行看左边。
* b:成员方法
* 编译看左边，运行看右边。
* c:静态方法
* 编译看左边，运行看左边。
* (静态和类相关，算不上重写，所以，访问还是左边的)

* D:多态的好处
* a:提高了代码的维护性(继承保证)
* b:提高了代码的扩展性(由多态保证)

* E:多态的弊端
* 不能使用子类的特有功能。

案例:

/*
  多态中的转型，向上转型，向下转型
  孔子案例
*/
class KongZiDie
{
int age = 70;
public void teacher(){
 System.out.println("讲地理");
}
}
class KongZi extends KongZiDie
{
int age = 40;
public void teacher(){
 System.out.println("讲论语");
}


public void playGame(){
 System.out.println("斗地主");
}
}
class DuoTaiDemo1 
{
public static void main(String[] args) 
{
   //多态调用方式，父类引用指向子类对象
//转型过程，子类提升为父类的类型，自动的提升
KongZiDie d = new KongZi();
System.out.println(d.age);
d.teacher();
//调用子类的特有功能，类型强制转换
//向下转型，将父类转成子类的类型
KongZi zi = (KongZi)d;
zi.playGame();


// KongZi z = new KongZiDie();
}
}
案例:

/*
  抽象类案例-老师
    基础老师 ： 成员 姓名，年龄 功能 上课
就业老师 ： 成员 姓名，年龄 功能 上课
  
  共性抽取 老师类 ： 成员 姓名，年龄，抽象方法上课
  创建老师对象，应该具备姓名和年龄
  抽象类的构造方法，可以给本类中的成员变量赋值
*/
//定义老师类，成员变量 name age 抽象方法上课
abstract class Teacher
{
private String name;
private int age;
    Teacher(String name,int age){
  this.name = name;
  this.age = age;
}
public void setName(String name){this.name=name;}
public void setAge(int age){this.age=age;}
public String getName(){return name;}
public int getAge(){return age;}


public abstract void teacher();
}
//定义基础老师，继承老师类，重写抽象方法
class JavaSE extends Teacher
{
//定义构造方法，接收创建对象的时候，传递的姓名和年龄
JavaSE(String name,int age){
    //使用super语句，将接收到的姓名年龄，送到父类中赋值
super(name,age);
}
    // 打印出老师的姓名和年龄
public void teacher(){
  System.out.println(getName()+getAge()+"基础老师讲 javase");
}
}
//定义就业老师，继承老师类，重写抽象方法
class JavaEE extends Teacher
{
JavaEE(String name,int age){
  super(name,age);
}
public void teacher(){
  System.out.println(getName()+getAge()+"就业老师讲 javaee三大框架");
}
}


class AbstractTeacherTest 
{
public static void main(String[] args) 
{
JavaSE se = new JavaSE("张三",20);
se.teacher();
JavaEE ee = new JavaEE("李四",21);
ee.teacher();
//System.out.println("Hello World!");
}