java 抽象 封装_java基础---抽象和封装

1.为什么使用面向对象？

现实世界是由什么组成的，世界由对象组成

面向对象的思想符合人类思维习惯，面向对象的思想描述面向对象的世界

2.软件出现的目的

n用计算机的语言描述现实世界

n用计算机解决现实世界的问题

3.面向对象设计和开发程序的好处

n交流更加流畅

n提高设计和开发效率

4.一个现实世界的问题

宠物——现实世界的对象

如何在计算机中描述它们?

从现实中抽象出类分三步：1. 找出它的种类2.找出它的属性3.找出它的行为

第一步：发现类(根据“对象”抽象出“类”)

class Dog {

}

第二步：发现类的属性(只放和业务相关的属性)

class Dog {

String name = "旺财"; //昵称

int health = 100; // 健康值

int love = 0; // 亲密度

String strain = "拉布拉多犬"; //品种

}

第三步：发现类的方法

class Dog {

String name = "旺财"; //昵称

int health = 100; // 健康值

int love = 0; // 亲密度

String strain = "拉布拉多犬"; //品种

/* 输出狗的信息*/

public void print() {

// 输出狗信息的代码

}

5.类图

举例：实现宠物领养

public class Dog {

// 狗狗实体类

// field

public String name;

public int health;

public int love;

public String strain;

// methods

public void print() {

System.out.println("姓名" + name + "健康值" + health + "可爱值" + love + "种类"

+ strain);

}

}

public class Penguin {

// 企鹅实体类

// field

public String name;

public int health;

public int love;

public String gender;

// methods

public void print() {

System.out.println("姓名" + name + "健康值" + health + "可爱值" + love + "种类"

+ gender);

}

}

import java.util.Scanner;

public class Adopt {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

String name = null;

Dog dog = null;

Penguin penguin = null;

int choice = 0;

String answer = "y";

while (answer.equals("y")) {

System.out.println("请输入领养宠物的名字");

name = input.next();

System.out.println("请输入您要领养宠物的类型;1-狗;2-企鹅");

choice = input.nextInt();

switch (choice) {

case 1:

// 领养狗

answer = "n";

System.out.println("请输入狗狗的种类,1-拉布拉多;2-哈士奇");

choice = input.nextInt();

dog = new Dog(); // 创建新的空间

dog.name = name;

if (choice == 1) {

dog.strain = "拉布拉多";

} else if (choice == 2) {

dog.strain = "哈士奇";

}

dog.love = 60;

dog.health = 60;*/

break;

case 2:

// 领养企鹅

answer = "n";

System.out.println("请输入企鹅的性别;1-Q仔;2-Q妹");

choice = input.nextInt();

penguin = new Penguin();

penguin.name = name;

if (choice == 1) {

penguin.gender = "Q" + "仔";

} else if (choice == 2) {

penguin.gender = "Q" + "妹";

}

penguin.love = 60;

penguin.health = 60;

break;

default:

System.out.println("对不起,输入有误,请重新输入");

break;

}

System.out.println("还要继续领养吗?  y-继续;n-退出");

answer = input.next();

}

// 输出

if (dog != null) {

dog.print();

}

if (penguin != null) {

penguin.print();

}

}

}

心得：根据现实世界的信息，用程序的角度去描述出来

因为Dog dog = null;为空，只做了一个房间，并没有赋值；所以使用dog.什么的时候需要new一个对象(不能给房间直接赋值)

如何查看领养了那个宠物，查看那个房间没有空着。则代表领养到了...

如果想重复领养，目前达不到，存放企鹅和狗狗的只有一个房间。多次领养无意义...

列表可以帮助实现

6.整理代码快捷键

Ctrl+shift+f

7.如何修改快捷键

Windows--->preference-->查找输入keys--->进行修改

8.封装-----构造方法

上述对宠物的初始化不方便，如果狗狗有100个属性则需要写100次dog.xx；且每次初始化dog，每次都需要重复写那么多。比较繁琐，应符合写少做多。

对象初始化

Penguin pgn=new Penguin();

pgn.name = "qq";

pgn.sex = "Q仔";

能否在创建对象的同时就完成赋值?构造方法(new完直接赋值)

构造方法是提前把属性写好

举例：无参构造方法

public class Dog {

// dog

// field

public String name;

public int health;

public int love;

public String strain;

//构造方法

//构造方法没有返回值

public Dog(){

name="旺仔";

health=60;

love=90;

strain="中华田园犬";

}

// methods

public void print() {

System.out.println("姓名" + name + "健康值" + health + "可爱值" + love + "种类"

+ strain);

}

}

public class Penguin {

// 企鹅

// field

public String name;

public int health;

public int love;

public String gender;

//构造方法

//构造方法没有返回值

public Penguin(){

name="QQ";

health=60;

love=60;

gender="Q仔";

}

// methods

public void print() {

System.out.println("姓名" + name + "健康值" + health + "可爱值" + love + "种类"

+ gender);

}

}

import java.util.Scanner;

public class Adopt {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

String name = null;

Dog dog = null;

Penguin penguin = null;

int choice = 0;

String answer = "y";

while (answer.equals("y")) {

System.out.println("请输入领养宠物的名字");

name = input.next();

System.out.println("请输入您要领养宠物的类型;1-狗;2-企鹅");

choice = input.nextInt();

switch (choice) {

case 1:

// 领养狗

answer = "n";

System.out.println("请输入狗狗的种类,1-拉布拉多;2-哈士奇");

choice = input.nextInt();

dog = new Dog(); // 创建新的空间

break;

case 2:

// 领养企鹅

answer = "n";

System.out.println("请输入企鹅的性别;1-Q仔;2-Q妹");

choice = input.nextInt();

penguin = new Penguin();

break;

default:

System.out.println("对不起,输入有误,请重新输入");

break;

}

System.out.println("还要继续领养吗?  y-继续;n-退出");

answer = input.next();

}

// 输出

if (dog != null) {

dog.print();

}

if (penguin != null) {

penguin.print();

}

}

}

9.无参类型构造方法

系统提供默认无参构造方法

语法:

访问修饰符 构造方法名 ( ) {

//初始化代码

}

示例:

public Penguin() {

}

10. 带参数的构造方法

所谓没有参数的构造方法就是指，需要自己做一个对象，不是按照意愿造出来的，而是系统提供什么就必须安要求来...

举例：

public class Dog {

// dog

// field

public String name;

public int health;

public int love;

public String strain;

// 带参数构造方法

// this-当前对象

public Dog(String name,int health,int love,String strain){

this.name=name;

this.health=health;

this.love=love;

this.strain=strain;

}

// methods

public void print() {

System.out.println("姓名" + name + "健康值" + health + "可爱值" + love + "种类"

+ strain);

}

}

public class DogTest {

public static void main(String[] args) {

// 带参数构造方法

Dog dog=new Dog("阿福",100,20,"沙皮");

dog.print();

}

}

心得：

带参数的构造方法可以按照自己的心意去做，所以需要输入一些东西，有什么属性输什么属性

需要把参数的信息挨个赋值给类的属性，利用this

This.name指的是public String name,然后把传过来的参数 给类的成员变量this.name=name

当没有无参数的方法时main不能添加Dog dog=new Dog();

11.带参数构造方法常见错误

举例：

public class Dog {

// dog

// field

public String name;

public int health;

public int love;

public String strain;

// 带参数构造方法

// this-当前对象

public Dog(String name,int health,int love,String strain){

this.name=name;

this.health=health;

this.love=love;

this.strain=strain;

}

// methods

public void print() {

System.out.println("姓名" + name + "健康值" + health + "可爱值" + love + "种类"

+ strain);

}

}

public class DogTest {

public static void main(String[] args) {

Dog dog=new Dog();

dog.print();

}

}

错在哪里？

1.前面一个类，后面一个测试类

测试类里面调用的是不带参数的构造方法，但本类里并没有提供不带参数的构造方法，故出错

2.当无参方法和有参数方法同时出现时，调用无参方法也会成功

12.不带参数的构造方法有俩个特点

1.系统默认提供无参构造方法

2.当系统还有带参数的构造方法时，系统不在提供默认的无参构造方法

补充：构造方法和一般方法区别

1)到目前为止，学习两种方法，分别为构造方法和一般方法，那么他们之间有什么异同呢？

构造方法在对象创建时就执行了，而且只执行一次。(类名与构造方法名相同、无返回值)

一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。(类名与方法相同或不同都可以、返回值为空或有返回值)

2)有了构造方法之后可以对对象的属性进行初始化，那么还需要对应的set和get方法吗？

需要相应的set和get方法，因为对象在创建之后需要修改和访问相应的属性值时，在这时只能通过set或者get方法来操作。

13.构造方法重载

变量不能同名、类不能同名、为什么方法可以同名？因为方法的重载

举例：

public class Demo {

/*方法的重载overload

*  1-两个方法  方法名相同

*  2-参数不同

*  3-与返回值 访问控制符无关

* */

public void print(){

System.out.println("打印");

}

public String print(int d){

System.out.println("打印");

return null;

}

}

14.构造方法重载的调用

pgn = new Penguin();

pgn.print();

pgn = new Penguin("美美", 80, 20, "Q仔");

pgn.print();

public Penguin () {

name = "qq";

love = 20;

sex = "Q仔";

}

public Penguin (String name,int health,int love,String sex ) {

this.name = name;

this.health = health;

this.love = love;

this.sex = sex;

}

15.static关键字

可以修饰成员变量、方法

修饰成员变量，通过类名直接访问成员变量

可以绕过new，直接拿类来访问不用拿对象来访问它。

无论修饰成员变量，还是成员方法static都写在类型的前面；在使用的时候不需要new对象

1-修饰成员变量  类名.fileldName

2-修饰成员方法  类名.methodName

3-修饰静态代码块

举例：变量

package demo1;

public class Penguin {

// static

//属性

public static String MALE="Q仔";

public static String FEMALE="Q妹";

}

package demo1;

public class PenguinTest {

public static void main(String[] args) {

//属性

System.out.println(Penguin .MALE);

System.out.println(Penguin.FEMALE);

}

}

心得：一般用static修饰的都大写

不用new和对象直接把属性使用

举例：方法

package demo1;

public class Penguin {

/*//方法

public static void test(){

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

}

}

package demo1;

public class PenguinTest {

public static void main(String[] args) {

//方法

Penguin.test();

}

}

举例：静态代码块

package demo1;

public class Penguin {

//无参数

public Penguin(){

System.out.println("无参...");

}

//静态代码块

//优先于构造方法去执行

static{

System.out.println("代码块");

System.out.println("静态代码块");

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

}

}

package demo1;

public class PenguinTest {

public static void main(String[] args) {

Penguin a=new Penguin();

}

}

16.为什么要使用封装

属性随意访问，不合理的赋值；如何解决，使用封装

举例：

package demo4;

public class Dog {

private String name;

private int love;

private int health;

private String strain;

/*

*

* set和get方法

*

* */

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getLove() {

return love;

}

public void setLove(int love) {

if(love<0||love>100) {

System.out.println("亲密度只能在0-100之间");

this.love=60;

}else{

this.love = love;

}

}

public int getHealth() {

return health;

}

public void setHealth(int health) {

if(health<0||health>100) {

System.out.println("健康值只能在0-100之间");

this.health=60;

}else{

this.health = health;

}

}

public String getStrain() {

return strain;

}

public void setStrain(String strain) {

this.strain = strain;

}

/*

*

* 带参数的构造方法

*

* */

public Dog(String name, int love, int health, String strain) {

super();

this.name = name;

this.love = love;

this.health = health;

this.strain = strain;

}

/*

*

* 不带参数的构造方法

*

*

* */

public Dog() {

super();

// TODO Auto-generated constructor stub

}

/*

*

* toString() 自动生成

*

* */

@Override

public String toString() {

return "Dog [name=" + name + ", love=" + love + ", health=" + health

+ ", strain=" + strain + "]";

}

}

package demo4;

import java.util.Scanner;

public class Adopt {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

String name = null;

Dog dog = null;

Penguin penguin = null;

int choice = 0;

String answer = "y";

while (answer.equals("y")) {

System.out.println("请输入领养宠物的名字");

name = input.next();

System.out.println("请输入您要领养宠物的类型;1-狗;2-企鹅");

choice = input.nextInt();

switch (choice) {

case 1:

// 领养狗

answer = "n";

System.out.println("请输入狗狗的种类,1-拉布拉多;2-哈士奇");

dog = new Dog(); // 创建新的空间

choice = input.nextInt();

if (choice == 1) {

dog.setStrain("拉布拉多");调用set方法

} else if (choice == 2) {

dog.setStrain("哈士奇");

}

dog.setName(name);

System.out.println("请输入狗狗的健康值");

dog.setHealth(input.nextInt());

System.out.println("请输入狗狗的可爱值");

dog.setLove(input.nextInt());

break;

case 2:

// 领养企鹅

answer = "n";

System.out.println("请输入企鹅的性别;1-Q仔;2-Q妹");

choice = input.nextInt();

penguin = new Penguin();

if (choice == 1) {

penguin.setGender(Penguin.MALE);

} else if (choice == 2) {

penguin.setGender(Penguin.FEMALE);

}

penguin.setName(name);

System.out.println("请输入企鹅的健康值");

penguin.setHealth(input.nextInt());

System.out.println("请输入企鹅的可爱值");

penguin.setLove(input.nextInt());

break;

default:

System.out.println("对不起,输入有误,请重新输入");

break;

}

System.out.println("还要继续领养吗?  y-继续;n-退出");

answer = input.next();

}

// 输出

if (dog != null) {

System.out.println(dog.toString());

} else if (penguin != null) {

System.out.println(penguin.toString());

}

}

}

心得：健康值属性不能被赋值-100，不能修改。想要实现不被修改，在测试类里随意添加这样是不合理的。不允许修改，故需要封装

封装分二步：1-将属性的访问符改为private

2-set   设置 修改

3-get   读  获取

做限制可以在set方法里做限制

Penguin.MALE  值被固定，不被修改

17.快捷键

Alt+shift+s

Get 、set、无参方法、带参方法可以帮助生成

但是自定义的方法和属性需要自己写

18.什么是封装

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

19. 如何使用封装

修改属性的可见性

1在getter/setter方法中加入属性控制语句(设为private)

2创建公有的getter/setter方法(用于属性的读写)

2在getter/setter方法中加入属性控制语句(对属性值的合法性进行判断)

20. this的用法

关键字this用来指向当前实例对象(内存里正在运行的哪个实例对象)，它的另一作用是用来区分对象的成员变量与方法的形参。

调用属性

this.health = 100;

this.name = "大黄";

调用方法

this.print();

调用构造方法

this();

this("小黑",100,100,"雄");

this();如果使用，必须是构造方法中的第一条语句

举例：

不能在普通方法里调用this();

只能在构造方法中调用this();

不能在无参中调用带参，只能在带参中调用无参数方法

this关键字主要有三个应用：

(1)this调用本类中的属性，也就是类中的成员变量；

(2)this调用本类中的其他方法；

(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。

Public Class Student {

String name; //定义一个成员变量name

private void SetName(String name) { //定义一个参数(局部变量)name

this.name=name; //将局部变量的值传递给成员变量

}

}

应用一：引用成员变量

如上面这段代码中，有一个成员变量name，同时在方法中有一个形式参数，名字也是name，然后在方法中将形式参数name的值传递给成员变量name，虽然我们可以看明白这个代码的含义，但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name，还是反过来将成员变量name的值传递给形式参数name呢?也就是说，两个变量名字如果相同的话，那么Java如何判断使用哪个变量?此时this这个关键字就起到作用了。this这个关键字其代表的就是对象中的成员变量或者方法。也就是说，如果在某个变量前面加上一个this关键字，其指的就是这个对象的成员变量或者方法，而不是指成员方法的形式参数或者局部变量。为此在上面这个代码中，this.name代表的就是对象中的成员变量，又叫做对象的属性，而后面的name则是方法的形式参数，代码this.name=name就是将形式参数的值传递给成员变量。这就是上面这个代码的具体含义。

21. 总结

抽象：用程序的语言描述现实世界

1-找到类

2-属性

3-方法

构造方法

作用：初始化对象属性

1-无参数

Public  类名(){

}

2-带参数

Public  类名(String name){

This.name=name；

}

A系统默认提供无参数的构造方法

B当系统提供了带参数的构造方法时，不在提供无参数方法

封装

1-将属性public变为private

2-增加get/set方法，读取/写入

3-重新修改set方法

Static

1-属性

2-方法

Person p=new Person()；

p.field ；

p.method；

--------------------------------------------

Person.filed；

Person.method()；

3-静态代码块

优先于构造方法去执行

Static{

}

方法的重载

1-同一个类中

2-俩个或多个同名方法

3-参数不同

4-与访问修饰符和返回值无关