java面向对象编程（上）

一、面向对象编程（OOP Object Oriented Programming）

何谓“面向对象”的编程思想？：

1、复杂的事情简单化

2、使我们的角色发生转变，从执行者转变成指挥者

3、面向对象具备很好的通用性和可拓展性

1.面向对象和面向过程：

①面向过程 ： 强调是功能行为

②面向对象 ： 将功能行为封装进对象，强调具备了功能行为的对象。

【例如】把大象装冰箱一共分几步？

①打开冰箱 ②把大象装进去（存储大象） ③关闭冰箱

如何运用面向对象思想思考上述问题：

人{

拉（冰箱）｛

冰箱.打开()

｝

指挥（大象）｛

大象.进入（）

｝

推(冰箱){

冰箱.关闭()

}

}

冰箱{

打开（）｛｝

存储（）｛｝

关闭（）｛｝

}

大象{

进入（）｛｝

}

面向对象更加注重前期的设计：

①就是对类的设计

②设计类就是设计类的成员：属性 & 方法

2. 面向对象：将现实生活中一类事物的共性内容，进行提取，抽象成相应的 Java 类，使用 Java 类对其进行描述

现实生活中的事物：张三 李四 王五

共性内容：姓名 性别 年龄 吃饭的功能 睡觉的功能

//抽象的

class Person{

//属性

String name;

char gender;

int age;

//方法-行为

public void eat(){

System.out.println("吃饭");

}

public void sleep(){

System.out.println("睡觉");

}

}

3. 类本身是抽象的，因为描述的是现实生活中所有的人。若需要具体到某一个人时：通过 new 关键字 创建对象

class TestPerson{

public static void main(String[] args){

//创建对象

Person p = new Person();

//设置属性值

p.name = "张三";

p.gender = '男';

p.age = 18;

//获取属性值

String n = p.name;

System.out.println(n + "," + p.age + "," + p.gender);

//调用对象的方法

p.eat();

p.sleep();

}

}

4. 类和对象：

类：抽象的，用于描述现实生活中的一类事物。 相当于汽车设计图

对象：是一个实实在在的个体。 相当于一辆辆的汽车

一、属性：也叫成员变量，也叫实例变量

1. 成员变量 & 局部变量的区别？

①内存中的位置不同

②作用域不同

③成员变量有默认值，而局部变量没有默认值（因此局部变量在使用前必须赋值）

2. 属性的默认值

基本数据类型：

byte short int ---> 0

long ---> 0L

float ---> 0.0F

double ---> 0.0D

char ---> '\u0000'

boolean ---> false

引用数据类型： ---> null

|-- 类（class）

|-- 接口（interface）

|-- 数组（[]）

3. 属性赋初始值的方式：

①使用默认值(缺省值)

②直接显示赋值

二、参数的值传递：

基本数据类型：若将基本数据类型作为参数传递给方法，方法运行结束后，原值不会发生改变

public static void main(String[] args){

//add(10, 20);

int a = 10;

int b = 20;

add(a, b);

System.out.println("a=" + a + " b=" + b); //a=10, b=20

}

public static void add(int a, int b){

a += 1;

b += 2;

}

引用数据类型：若将引用数据类型作为参数传递给方法，方法运行结束后，原值会发生改变

public static void main(String[] args){

//add(new Number1());

Number1 n = new Number1();

n.a = 10;

n.b = 20;

add(n);

System.out.println("n.a=" + n.a + " n.b=" + n.b);//n.a=11, n.b=22

}

public static void add(Number1 num){ //Number1 num = new Number();

num.a += 1;

num.b += 2;

}

class Number1(){

//属性

int a;

int b;

}

一、内存管理：

分配：由 JVM 自动为其分配内存空间

释放：由 JVM 提供的垃圾回收机制自动释放内存空间

1. 垃圾回收机制（garbage collection GC） : 将内存中的垃圾对象从内存中释放

2. 垃圾对象 : 不再被任何引用指向的对象

如：

Person p = new Person(); //分配内存

p = null;

3. System.gc() : 用于通知 垃圾回收机制 可以释放内存，但是垃圾回收机制并不会立即的释放内存

（可以加快垃圾回收机制的运行）

一、面向对象的特性之一：封装性

1. 封装的理解：把该隐藏的隐藏起来，该暴露的暴露出来

2. 访问控制修饰符：

public : 公共的，可用于修饰 属性、方法、类。 在任何地方都可以访问

private : 私有的，可用于修饰 属性、方法。 只能在本类中访问

3. 封装的步骤

①属性私有化(private)

②提供公共的(public) get/set 方法

class Animal{

private String name;

private int legs;//描述腿的个数

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

//设置属性值

public void setLegs(int legs){

if(legs > 0 && legs <= 4 && legs % 2 == 0){

this.legs = legs;

}

}

//获取属性值

public int getLegs(){

return legs;

}

}

Animal a1 = new Animal();

a1.name = "大象";

//a1.legs = -1000;

a1.setLegs(-1000);

System.out.println(a1.getLegs());

一、this 关键字：使用在本类中，代表当前对象，可用于调用 属性、方法、构造器

this.属性

this.方法

this(……) ： 调用本类构造器

①this 调用本类构造器必须写在当前构造器可执行代码的首行

②避免递归构造器调用（至少有一个构造器中不使用 this）

2. 谁让拥有 this 关键字的方法运行了，谁就是当前对象

class Person{

private String name;

private int age;

public void setName(String name){

this.name = name; //this 可用于区分局部变量和成员变量

}

public String getName(){

return name;

}

public String say(){

return this.getName();

}

}

一、构造器：也叫构造方法，是类的成员之一

属性

方法

构造器

1. 构造器的格式：

访问控制修饰符 类名(参数列表){

//功能语句

}

2. 构造器的作用

①创建对象

②为对象进行初始化

3. 构造器的注意：

①构造器的名称必须与类名一致！

②若一个类中没有提供任何构造器时，系统提供一个默认无参构造器

public Person(){}

③若一个类中显示的提供的任何构造器，系统默认无参构造器将不再提供

④构造器没有返回值，也不需要 return

⑤构造器之间可以构成重载

⑥构造器只能调用一次， 并且是在创建对象的时候（若再次调用，则是一个新对象）

4. 构造器的重载

在同一个类中

①构造器的名称相同

②参数列表不同（参数的个数、参数的类型）

5. 为属性赋初始值的方式

①使用默认赋值

②直接显示赋值

③构造器赋值

顺序： ①②③

class Person{

//属性

private String name;

private int age;

private char gender;

private double weight;

//声明一个构造器

public Person(){

System.out.println("Person's Constructor……");

}

public Person(String name, int age){

this.name = name;

this.age = age;

}

public Person(String name, int age, char gender, double weight){

this(name, age);

this.gender = gender;

this.weight = weight;

}

//方法

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

}

Person p = new Person();

Person p2 = new Person("张三", 18);

//new Person("张思");

一、包的作用：

①用于区分重命名

②用于控制访问权限

③用于划分项目的结构层次，通常将功能相近的类划分到同一个包中

1. package : 用于确定当前类的位置

①写在当前 .java 源文件可执行代码的首行

②包的命名规范：所有字母都小写。 （通常将公司域名的倒置。 如：com.atguigu.项目名.模块名）

③每个 "." 代表一层目录

2. import : 用于确定需要引入类的位置

①写在 package 与 class 之间

②import 可以有多条，并排列出

③import com.atguigu.java.*; 代表导入 java 下所有的类或接口。 （不包括包）

④若在一个类中使用了两个相同类名，不同包名的两个类时

如： java.util.Date; java.sql.Date;

选择一个使用 import java.util.Date;

选择另一个使用全限定类名(全类名) java.sql.Date date = new java.sql.Date(125367);

⑤ import static 静态导包，可以导入一个类中所有的静态成员