面向对象介绍以及封装

面向对象基本概念

课程大纲

什么是面向对象

面向对象是一种编程思想

面向对象是一种思考问题的思维方式

如何建立面向对象思维

先整体在局部

先抽象在具体

能做什么，再做什么

如何学习面向对象

掌握一种面向对象语言的语法

熟悉面向对象的设计原则

熟悉面向对象的设计模式

类和对象的概念

课程大纲：

什么是类

类是：类别，分类

通过分类，我们可以区别不同的事物种类，日常生活中常常这样做

类是一组具有相同特性（属性）和行为（方法）的事物的集合

类和对象的关系

类表示一个共性的产物，是一个综合的特征，而对象是一个个性的产物，一个个体的特征

类由属性和方法组成

属性：就相当于一个特征

方法：就相当于人的一种行为：例如：吃饭，睡觉，说话，唱歌

类的定义格式

课程大纲：

类的定义格式

在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;

}

}