课程大纲
什么是面向对象
面向对象是一种编程思想
面向对象是一种思考问题的思维方式
如何建立面向对象思维
先整体在局部
先抽象在具体
能做什么，再做什么
如何学习面向对象
掌握一种面向对象语言的语法
熟悉面向对象的设计原则
熟悉面向对象的设计模式
课程大纲：
什么是类
类是：类别，分类
通过分类，我们可以区别不同的事物种类，日常生活中常常这样做
类是一组具有相同特性（属性）和行为（方法）的事物的集合
类和对象的关系
类表示一个共性的产物，是一个综合的特征，而对象是一个个性的产物，一个个体的特征
类由属性和方法组成
属性：就相当于一个特征
方法：就相当于人的一种行为：例如：吃饭，睡觉，说话，唱歌
课程大纲：
类的定义格式
在Java中定义一个类
Calss 类名
{
属性名称；
返回值类型 方法名（）{}
}
/**
定义一个小鸡类
*/
class Chicken
{
//定义小鸡的属性
int color;
char sex;
int age;
//定义小鸡的方法
void eat()
{
System.out.println("小鸡吃小米！");
}
//main方法，程序的入口
public statice void main(String[] args)
{
Chicken c1 = new Chicken();
c1.color = 1;
c1.sex = ‘母‘;
c1.age = 1;
c1.eat();
}
}
课程大纲：
对象的定义格式
一个类要想真正的操作，必须依靠对象，对象的定义格式如下
类名 对象名 = new 类名()；按照以上的格式就可以产生对象了
访问类中的属性和方法
访问类中的属性：
对象.属性
访问类中的方法
对象.方法
/**
定义一个小鸡类
*/
class Chicken
{
//定义小鸡的属性
int color;
char sex;
int age;
//定义小鸡的方法
void eat()
{
System.out.println("小鸡吃小米！");
}
//main方法，程序的入口
public static void main(String[] args)
{
Chicken c1 = new Chicken();
c1.color = 1;
c1.sex = ‘母‘;
c1.age = 1;
c1.eat();
}
}
课程大纲
new关键字深入
new关键字表示创建一个对象
new关键字表示实例化对象
new关键字表示申请内存空间
注意：如果使用一个没有申请内存空间的对象会报空指针异常
对象内存分析
作业
根据面向对象思想设计一个猪类
根据面向对象思想设计一个美女类
/**
根据面向对象思想创建一个猪类
*/
class HomeWork1
{
public static void main(String[] args)
{
Pig p = new Pig();
p.name = "小白";
p.age = 20;
p.weight = 800;
p.eat();
p.sleep();
p.say();
}
}
class Pig
{
String name;
int age;
int weight;
void eat()
{
System.out.println("我是猪，我什么都能吃！");
}
void sleep()
{
System.out.println("我就能睡觉！");
}
void say()
{
System.out.println("我的年龄是"+age+"，名字是"+name+"，体重是："+weight);
}
}
/**
根据面向对象思想创建一个美女类
*/
class HomeWork2
{
public static void main(String[] args)
{
Beauty g = new Beauty();
g.name = "小白";
g.age = 18;
g.say();
}
}
class Beauty
{
String name;
int age;
void say()
{
System.out.println("我的名字是："+name+",年龄是："+age);
}
}
/**
new关键字的深入与内存结构
*/
public classNewKeyWordDemo
{
public static void main(String[] args)
{
Dog dog = null;//声明一个对象
dog = new Dog();//实例化对象
//Dog dog = new Dog();
dog.name = "小白";//给对象初始化
dog.age = 10;//给对象初始化
dog.say();
//-------------------
Dog dog2 = null;
dog2 = new Dog();
Dog dog3 = null;
dog3 = new Dog();
//分别给两个对象赋值
dog2.name = "小白";
dog2.age = 10;
dog3.name = "小黑";
dog3.age = 10;
dog3 = dog2;
dog3.name = "小黄";
System.out.println(dog2.name);
}
}
class Dog
{
String name;
int age;
void say()
{
System.out.println("我的名字是："+name+"我的年龄是："+age);
}
}
封装性的概念
封装是面向对象的三大特性之一
封装隐藏内部实现细节，仅对外提供访问接口
常见的封装有：
属性的封装
方法的封装
类的封装
组件的封装
模块化封装
系统级封装
封装的好处
模块化
信息隐蔽
代码重用
具有安全性
插件易于调试
属性的封装
封装之前：
Class Person{
String name;
Int age;
}
封装之后：
Class Person{
PrivateString name;
Private intage;
Public voidsetName(String name)
{
This.name =name;
}
Public String getName()
{
Return name;
}
}
/**
属性的封装
*/
classEncapsulationDemo
{
public static void main(String[] args)
{
Person p = new Person();
p.setName("小白");
p.setAge(18);
p.say();
//------------------
String name = "小黑";
Person p1 = new Person(name);
Person p2 = new Person("小黑",18);
}
}
class Person
{
//属性的封装private，只能在本类中访问
//为属性提供getter/setter方法
private String name;
private int age;
//属性的读写操作方法
public Person()//默认构造方法
{
System.out.println("这是默认构造方法！");
}
public Person(String name)//带有一个参数的构造方法
{
this.name = name;
System.out.println("带有一个参数的构造方法！");
}
public Person(String name, int age)//带有两个参数的构造方法
{
this.name = name;
this.age = age;
System.out.println("这是带有多个参数的构造方法！");
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
void say()
{
System.out.println("我的名字是："+name+"，年龄是："+age);
}
}
什么是构造方法
构造方法就是在类构造对象时调用的方法，用于对象的初始化工作
构造方法是实例化一个类的对象时（也就是new的时候）最先调用的方法
构造方法的定义
构造方法是在类中定义的，构造方法的定义格式：
方法名与类名相同
无返回值类型的声明
对象的实例化语法：
Duckduck = new Duck() //Duck后面带括号表明调用了方法，调用的方法就是构造方法
构造方法的重载
无参的构造方法：
Public Person(){};
带有一个参数的构造方法
Public Person(String name){
this.name = name;
}
带有两个参数的构造方：
Public Person(String name , intage ){
this.name = name;
this.age = age;
}
/**
属性的封装
*/
classEncapsulationDemo
{
public static void main(String[] args)
{
Person p = new Person();
p.setName("小白");
p.setAge(18);
p.say();
//------------------
String name = "小黑";
Person p1 = new Person(name);
Person p2 = new Person("小黑",18);
}
}
class Person
{
//属性的封装private，只能在本类中访问
//为属性提供getter/setter方法
private String name;
private int age;
//属性的读写操作方法
public Person()//默认构造方法
{
System.out.println("这是默认构造方法！");
}
public Person(String name)//带有一个参数的构造方法
{
this.name = name;
System.out.println("带有一个参数的构造方法！");
}
public Person(String name, int age)//带有两个参数的构造方法
{
this.name = name;
this.age = age;
System.out.println("这是带有多个参数的构造方法！");
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
void say()
{
System.out.println("我的名字是："+name+"，年龄是："+age);
}
}
方法的重载
方法重载：overloading method
在类中可以创建多个方法，他们具有相同的名字，但具有不同参数和不同的定义
（参数个数，类型，顺序）
/**
方法重载，（overloading method）
方法名相同，参数不同
*/
classOverloadingMethod
{
public static void main(String[] args)
{
Woman w = new Woman("小白");
w.PruductionOfChildren();
w.PruductionOfChildren("小黑");
w.PruductionOfChildren("小黑",‘女‘);
}
}
class Woman
{
String name;
public Woman(String name)
{
this.name = name;
System.out.println("调用构造方法！");
}
//生小孩的方法（方法重载）
public void PruductionOfChildren()
{
System.out.println("生了一个小孩");
}
public void PruductionOfChildren(StringnickName)
{
System.out.println("生了一个小孩,名字叫："+nickName);
}
public void PruductionOfChildren(StringnickName,char sex)
{
System.out.println("生了一个小孩,名字叫："+nickName+",是个"+sex+"孩！");
}
}
匿名对象
匿名对象就是定义一个没有名称的对象
该对象的特点事只能调用一次
该对象会直接在堆中开辟内存空间
该对象使用后会成为垃圾对象，被GC回收
作业
1、设计一个学生类，学生有三项成绩：计算机，体育，音乐，可以求出成绩的总分，平均分，最高和最低，并且可以输出学生的全部信息。
/**
匿名对象
*/
classAnonymousObject
{
public static void main(String[] args)
{
//匿名对象(同时调用含参构造方法)
new Student("小白",18).say();
}
}
class Student
{
private String name;
private int age;
//无参构造方法
public Student()
{
}
//有参构造方法
public Student(String name,int age)
{
this.name = name;
this.age = age;
}
public void say()
{
System.out.println("我的名字叫："+name+",年龄是："+age);
}
}
/**
设计一个学生类，学生有三项成绩：计算机，体育，音乐，
可以求出成绩的总分，平均分，最高和最低，
并且可以输出学生的全部信息。
*/
class HomeWork1
{
public static void main(String[] args)
{
Student s = new Student("小白",90.8f,89.9f,98f);
/*s.show();
s.sum();
s.avg();
s.topScore();
*/
System.out.println(s.show());
System.out.println(s.sum());
System.out.println(s.avg());
System.out.println(s.topScore());
}
}
class Student
{ //学生属性
private String name;
private float computer;
private float sport;
private float music;
//定义无参的构造方法，默认就有，但是一般要保留
public Student(){}
//定义含参的构造方法
public Student( String name,floatcomputer,float sport,float music)
{
this.name = name;
this.computer = computer;
this.sport = sport;
this.music = music;
}
//定义getter/setter方法（每一个属性都有一对）
//这里只定义了一个name属性，其他的略
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
//求总分
public float sum()//void
{
float sum = computer + sport + music;
//System.out.println(sum);
return sum;
}
//求平均分
public float avg()
{
float avg = (computer + sport + music)/3;
//System.out.println(avg);
return avg;
}
//求最高分
public float topScore()
{
float max = (computer>sport)?computer:sport;
max = (max>music)?max:music;
//System.out.println(max);
return max;
}
//最低分略
//输出全部信息
public String show()
{
//System.out.println("我的名字是"+name+"计算机成绩是"+computer+"体育成绩是"+sport+"音乐成绩是"+music);
return "我的名字是"+name+"计算机成绩是"+computer+"体育成绩是"+sport+"音乐成绩是"+music;
}
}
原文：http://blog.csdn.net/u014756517/article/details/51065781