java学习第08天--类|对象|封装

对象和类

对象：对象是类的一个实例（具体），有状态和行为。是一个动态的概念，对象的属性可以随着它自己的行为而发生改变。

类：类是一个模版，他描述的是一类对象的行为和状态。

例：Java中类的定义：

/*

Car 类

*/

public class Car{ //定义一个名为car的类

//定义成员变量

String color;

int year;

int price;

//定义成员方法

public void run(){

System.out.println("the car is running...");

}

}

类成员的写法:

成员变量：

  和之前定义变量的规则一样

  写在类中，成员方法的外边

成员方法：

  和之前定义方法的规则一样

  暂时去掉static

例如:public class car{}

练习:将笔记本电脑的信息通过类表现出来

自定义NoteBook类:

/*

自定义电脑类

成员变量

成员方法

如何使用一个自定义类:

创建对象,并访问对象的成员变量,调用成员方法

*/

public class NoteBook{

//成员变量(成员变量有默认值)

int price;

int size;

int memory = 4;//显式初始化

String color = "red";

//成员方法

public void playMusic(){

System.out.println("播放音乐");

}

public void playMovie(){

System.out.println("播放电影");

}

}

NoteBook测试类:

/*

NoteBook的测试类

*/

public class NoteBookDemo{

public static void main(String[] args){

//创建对象

//类名 变量名(对象名) = new 类名();

//Scanner s = new Scanner(System.in);

NoteBook note = new NoteBook();

//访问成员变量

System.out.println(note.price +","+ note.size +","+ note.memory +","+ note.color);//

//改变成员变量的值

note.price = 1000;

note.size = 15;

note.memory = 8;

note.color = "black";

System.out.println(note.price +","+ note.size +","+ note.memory +","+ note.color);//

//调用对象的方法

note.playMusic();

note.playMovie();

NoteBook n2 = new NoteBook();

System.out.println(n2.price +","+ n2.size +","+ n2.memory +","+ n2.color);

n2.playMusic();

n2.playMovie();

}

}

成员变量和局部变量的区别

• 成员变量（目前都是实例变量）：

– 成员变量定义在类中，作用范围是 整个类

– 实例变量随着对象的创建而存在，随着对象消失；存在于对象所在的 堆内存 中

– 成员变量 有默认初始化值（ 0/0.0/false/null ）

• 局部变量：

– 局部变量定义在局部范围内： 方法内，形参上，代码块内

– 局部变量存在于栈内存中

– 方法或者语句执行完，变量空间自动释放

– 局部变量 没有默认初始化值 ，除了形参，使用之前必须赋值

封装（Encapsulation）

封装:是指隐藏对象的属性和实现细节,仅对外提供公共的访问的方式.

这样做的好处是:

1、防止数据被任意篡改,提高安全性;

2、隐藏了实现细节,仅暴露方法.

3、良好的封装能够减少耦合(即代码的重复性)

4、类内部的结构可以自由修改

5、可以对成员变量进行更精确的控制

实现封装:

1: 使用private关键字修饰成员变量;

2: 对外提供公有的setter和getter方法

实现Java封装的步骤

1、修改属性的可见性来限制对属性的访问(一般限制为private)

public class Person{

//使用private修饰成员变量

private String name;

private int age;

}

将name和age属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就实现了对信息的隐藏.

2、 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

public class Person{

//使用private修饰成员变量

private String name;

private int age;

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;

}

private void eat(){

System.out.println("eat().....");

}

public void method(){

eat();

}

}

注解:

set为设置为意思,get为获取的意思,在类中使用set和get的方法时,都是在set和get后跟上一些特定词从而形成特定的意思的方法名,比如 setName,getName,setAge,getAge.

this关键字表示当前正在调用方法的对象.

Person测试类代码:

public class PersonDemo{

public static void main(String[] args){

//创建Person对象p

Person p = new Person();

p.setName("congzhongzhi");

p.setAge(26);

System.out.println(p.getName()+","+p.getAge());

p.method();

}

}

构造函数(构造器)

构造函数是一个特殊的方法,这个特殊方法用于创建实例时执行初始化.构造函数是创建对象的重要途径.当创建一个对象时,系统会为这个对象的实例变量进行默认的初始化,这活在那个默认的初始化把所有的基本类型的实例变量设为0或false,把所有的引用类型的实例变量设为null

特点:

1、构造方法是一种特殊的方法,它的方法名与类名相同.

2、不需要定义返回值类型,不用return关键字

3、其返回值可以理解为是新创建对象的引用,不用显示定义

注意:

1、如果没有写,系统会提供一个默认的构造方法.

例如我们使用的Scanner sc = new Scanner();就是使用系统提供的默认的构造方法

2、多个构造方法是以重载的形式存在的

3、使用new student();实际上就是调用空参构造方法

构造函数的使用

/*

自定义笔记本类

*/

public class NoteBook{

//定义私有变量

private String color;

private int price;

//创建构造方法,两个形参

public NoteBook(String color,int price){

System.out.println("调用两个参数:");

this.color = color;

this.price = price;

}

//创建构造方法,一个形参

public NoteBook(String color){

System.out.println("调用一个参数:");

this.color = color;

}

public void show(){

System.out.println(color +" <==> "+ price);

}

}

NoteBookDemo测试类:

public class NoteBookDemo{

public static void main(String[] args){

//创建对象,由于是构造方法,所以在创建对象时直接进行初始化

NoteBook n = new NoteBook("gold",7000);//赋予两个实参

n.show();

NoteBook n2 = new NoteBook("red");//赋予一个实参

n2.show();

}

}

一个对象的初始化(实例化)的过程

以Student s = new Student(); 为例

1. 加载Student.class 文件到方法区

2. 在栈内存中定义变量s

3. 在堆内存中开辟空间

4. 对成员变量进行默认初始化(0/0.0/false/null)

5. 对成员变量进行显式初始化

6. 调用构造方法( 成员变量赋值)

7. 成员变量初始化完毕，将对象的地址值返回给栈中的变量s

详细注解:

Student s = new Student();

new Student(); //在堆中动态分配一块区域,被当做了s对象

s //s本身的内存是在栈中分配的,堆中内存的地址赋值给了s,从而

//实现了s指向堆中的内存地址,s代表了堆中的内存

面向对象练习

1、 定义长方形类，其中包含求周长（perimeter ）和面积（area ）的方法

    注意：由于没有必要单独获取长和宽，所以不用定义get 方法

自定义类:

public class Rectangle{

private int length;

private int width;

public void setLength(int length){

this.length = length;

}

public void setWidth(int width){

this.width = width;

}

public int getPerimeter(){

int res1 = (length + width) * 2;

return res1;

}

public int getArea(){

int res2 = length * width;

return res2;

}

}

自动以测试类:

public class RectangleDemo{

public static void main(String[] args){

//创建对象

Rectangle r = new Rectangle();

r.setLength(5);

r.setWidth(2);

System.out.println("周长为" + r.getPerimeter());

System.out.println("面积为" + r.getArea());

}

}

使用构造函数的进行表示:

自定义类:

public class Rectangle{

private int length;

private int width;

//自定义构造函数

public Rectangle(int length,int width){

this.length = length;

this.width = width;

}

public int getPerimeter(){

int res1 = (length + width) * 2;

return res1;

}

public int getArea(){

int res2 = length * width;

return res2;

}

}

自定义测试类:

public class RectangleDemo{

public static void main(String[] args){

//创建对象

Rectangle r = new Rectangle(5,2);

System.out.println("周长为" + r.getPerimeter());

System.out.println("面积为" + r.getArea());

}

}

2、 定义员工类，自己分析有什么成员变量，包含一个显示所有成员变量的方法，然后测试.

1)使用构造函数表示

自定义员工类:

public class Employee{

private String dept;

private String name;

private String number;

//自定义构造函数

public Employee(String dept,String name,String number){

this.dept =dept;

this.name = name;

this.number = number;

}

public void setDept(String dept){

this.dept = dept;

}

public String getDept(){

return dept;

}

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

public void setNumber(String number){

this.number = number;

}

public String getNumber(){

return number;

}

public void show(){

System.out.println("部门:" + dept + "\r\n姓名:" + name + "\r\n工号:" + number);

}

}

自定义测试类:

public class EmployeeDemo{

public static void main(String[] args){

//使用构造函数方法

Employee emp = new Employee("SD","czz","12345");

//使用set方法

/*

Employee emp = new Employee();

emp.setDept("RD");

emp.setName("丛中之");

emp.setNumber("ID0003");

*/

emp.show();

}

}

2)使用setxxx方法表示

class Employ{

private String name;

private String id;

private int age;

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

public void setId(String id){

this.id = id;

}

public String getId(){

return id;

}

public void setAge(int age){

this.age = age;

}

public int getAge(){

return age;

}

public void show(){

System.out.println("姓名:" + name + "\r\n工号:" + id + "\r\n年龄:" + age);

}

}

public class Employee{

public static void main(String[] args){

//创建对象

Employ e = new Employ();

//调用set方法,不能出现等号,例如e.setName=("丛中之");,会出现报错,报错信息为: 找不到符号

e.setName("丛中之");

e.setId("001");

e.setAge(26);

e.show();

}

}

3、 自定义计算类，提供基本的加减乘除运算，并测试.

被计算的数和类之间没有从属关系, 最好不定义成成员变量, 而是方法的参数

自定义计算类:

public class Calc{

public int add(int a,int b){

return a + b;

}

public int sub(int a,int b){

return a - b;

}

public int mul(int a,int b){

return a * b;

}

public int dev(int a, int b){

return a / b;

}

}

自定义测试类:

public class CalcDemo{

public static void main(String[] args){

Calc c = new Calc();

int a = 10;

int b = 2;

System.out.println("两数之和: " + c.add(a,b));

System.out.println("两数之差: " + c.sub(a,b));

System.out.println("两数之积: " + c.mul(a,b));

System.out.println("两数之商: " + c.dev(a,b));

}

}

static(静态)关键字

static修饰的成员属于类,可以通过类名和对象名两种方式调用

非static修饰的成员属于实例对象,只能使用对象名的方式调用

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

案例:

class Teacher{

public String name;

static String color;

public Teacher(String name,String color){

this.name = name;

this.color =color;

}

public Teacher(String name){

this.name = name;

}

public void show(){

System.out.println("姓名:" + name + "\r\n颜色:" + color);

}

/ /类方法:既可以用(对象名.)调用,也可以用(类名.)调用

public static void method(){

//静态方法中不能使用this,super关键字,否则报错:无法从静态上下文中引用非静态 变量 this

// this.show();

System.out.println("method()........");

}

}

public class TeacherDemo{

public static void main(String[] args){

//创建对象

Teacher t1 = new Teacher("丛中之","红色");

Teacher t2 = new Teacher("倪玲");

t1.show();

t2.show();

//用类名直接调用类方法

// Teacher.method();

//用对象名直接调用类方法

t1.method();

t2.method();

}

}

静态变量和实例变量的区别

Ø 所属不同

静态变量属于类，也称为类变量

实例变量属于对象，也称为对象 ( 实例 ) 变量

Ø 在内存中的位置不同

静态变量在方法区中的静态区

实例变量在堆内存

Ø 生命周期不同

静态变量随着类的加载而加载，随着类的消失而消失

实例变量随着对象的创建而存在，随着对象的消失而消失

Ø 调用方法不同

静态变量可以通过类名和对象名两种方式调动，推荐使用类名调用

实例变量只能使用对象名的方式调用