面向对象
1. 程序
模拟现实世界，解决现实问题
就是在我们程序中，能够表示现实世界中的任何东西
2. 现实世界中是啥/对象
在程序员眼里，现实中任何一个具体的东西，都是对象
万物皆对象
我们研究,使用一个具体的东西，就相当于在程序中操作他的属性，方法
属性 描述东西
方法 操作东西
3. 如果在程序中定义一个对象
首先创造这类东西所属的品类
定义该类事物所属的品类
使用new关键字创建对象
package com.qfedu;
/*
* 表示电脑的品类 ： 代表全部的电脑
*/
public class Computer {
}
package com.qfedu;
/*
* 人类
*/
public class Human {
}
package com.qfedu;
public class Demo01 {
public static void main(String[] args) {
/*
* 在程序中表示现实世界中一台具体电脑
*
* 自定义类 变量 = new 自定义类();
*/
Computer com = new Computer();
/*
* human就表示现实世界中一个具体的人
*/
Human human = new Human();
/*
* 在java表示一个具体的杯子，鸭子
*
* 1. 创建杯子类
* 2. new
*/
Cup c = new Cup();
}
}
4. 如何定义类
类就是class，表示一类事物，可以定义属性和方法
属性 用来表述这类事物
方法 这类事物能够做什么
电脑：
属性：品牌，价格，颜色，cup
方法：看电影，打游戏，编码
package com.qfedu;
/*
* 表示电脑类 表示电脑这类事物
* 实体类
*/
public class Computer {
/*
* 定义属性：用来描述电脑 定义的是电脑的特征
* 1. 属性就是变量
* 2. 直接定义在类中
* 3. 可以使用 对象.属性名 设置或者获取属性的值
*/
String brand;
double price;
String color;
String cpu;
/*
* 定义方法 ： 表示这类事物能够做什么
*
* - 不写static
* - 实例方法
* - 对象.方法名(实参....);
*/
public void playGame() {
System.out.println("使用"+brand+"电脑，打游戏");
}
}
package com.qfedu;
public class Demo01 {
public static void main(String[] args) {
//创建电脑的对象
Computer c1 = new Computer();
//为该对象的属性赋值
c1.brand = "huawei";
c1.price = 6000.0;
c1.color = "绿色";
c1.cpu = "i9";
//获取属性值
String b = c1.brand;
double p = c1.price;
String c = c1.color;
String cpu = c1.cpu;
System.out.println("brand:"+b+",price:"+p);
//调用方法
c1.playGame();
/*
* 表示和表述你的手机
* 1. 创建手机类
* 2. 定义手机属性
* 品牌，价格，颜色
* 3. 创建手机对象
* 4. 为手机对象的属性赋值
*
*
* 定义手机拍照方法
* 使用对象调用该方法
*/
}
}
4.1 属性/实例变量
属性是这类事物的一个特征
属性也是变量
定义在类中，不是定义在方法中
属性也被称为全局变量，实例变量，成员变量
属性的作用范围是整个类
属性是有默认值
基本类型
整数（byte short int long） 0
小数（float double） 0.0
布尔（boolean） false
字符（char） 0
引用类型 null
可以通过 对象.属性名 设置或获取属性的值
4.2 局部变量
定义在方法中的变量叫做局部变量
方法中形参也是局部变量
局部变量的使用范围，在离它最近的大括号内（它所定义的大括号内）
没有初始化的变量不能使用，没有默认值
可以定义局部变量的名称和属性名一样，如果在相同所用范围内，使用该变量，默认使用的局部变量
4.3 实例变量和局部变量的比较
| 实例变量 | 局部变量 | |
|---|---|---|
| 定义位置 | 类中（不能是方法中） | 方法中 |
| 默认值 | 有 | 无 |
| 使用范围 | 整个类 | 所定义的大括号 |
| 名称冲突 | 一个类中不能有两个属性名相同 | 允许和实例变量相同，优先使用局部变量 |
4.4 实例方法
在类（实体类）中，方法表示该类事物能够做的事情。
public void/返回数据类型 方法名(参数列表) {
//方法体
return 值;
}
必须使用 对象.方法名() 调用方法
表示哪一个具体的事物，执行了这个操作
package com.qfedu;
/*
* 表示电脑类 表示电脑这类事物
*
* 实体类
*/
public class Computer {
/*
* 定义属性：用来描述电脑 定义的是电脑的特征
* 1. 属性就是变量
* 2. 直接定义在类中
* 3. 可以使用 对象.属性名 设置或者获取属性的值
*/
String brand;
double price;
String color;
String cpu;
/*
* 定义方法 ： 表示这类事物能够做什么
*
* - 不写static
* - 实例方法
* - 对象.方法名(实参....);
*/
public void playGame() {
System.out.println("使用"+brand+"电脑，打游戏");
}
}
package com.qfedu;
public class Demo01 {
public static void main(String[] args) {
//创建电脑的对象
Computer c1 = new Computer();
//为该对象的属性赋值
c1.brand = "huawei";
c1.price = 6000.0;
c1.color = "绿色";
c1.cpu = "i9";
//获取属性值
String b = c1.brand;
double p = c1.price;
String c = c1.color;
String cpu = c1.cpu;
System.out.println("brand:"+b+",price:"+p);
//调用方法
c1.playGame();
}
}
方法的重载
方法的重载：在同一个类中，方法名相同，参数列表页不相同
方法的签名（唯一性）:方法名，参数列表
- 在同一个类中，不允许两个方法，方法名相同，参数列表页相同
- - 参数列表相同：参数的个数，参数的类型，参数的顺序都相同
package com.qfedu;
public class MathUtil {
/*
*
*
* 在同一个类中，不允许两个方法，方法名相同，参数列表页相同
* 参数列表相同：参数的个数，参数的类型，参数的顺序都相同
*
* 方法的重载 : 在同一个类中，如果多个方法 方法名相同，而参数列表不同，就叫做方法的重载
* - 和返回值没有关系
*
*
*/
//定义方法求多个整数的和
public int sum(int a, int b) {
System.out.println("sum(int a, int b)");
return a+b;
}
public double sum(double a, double b) {
return a+b;
}
public double sum(int a, double b) {
return a+b;
}
public double sum(double a, int b) {
System.out.println("double sum(double a, int b)");
return a+b;
}
public static void main(String[] args) {
MathUtil util = new MathUtil();
/*
* 一旦方法出现了重写，那就根据参数的类型，找到相应的方法，执行
*/
double r1 = util.sum(1.1, 2);
}
}
构造方法
对象的执行流程
构造方法
在类中，有一种特殊的方法 : 构造方法
不用定义static
不能定义返回值类型，也不能定义void
方法名和类名一模一样(一定是当前类的类名)
不能通过对象调用
pulic 类名() {
}
pulic 类名(参数列表) {
}
package com.qfedu;
public class Demo01 {
public static void main(String[] args) {
Computer c = new Computer(1,2);
}
}
class Computer {
String brand;
double price;
String color;
String cpu;
/*
* 在类中，有一种特殊的方法 : 构造方法
* - 不用定义static
* - 不能定义返回值类型，也不能定义void
* - 方法名和类名一模一样
* - 不能通过对象调用
*
* - 创建对象的执行
*
*/
public Computer() {
System.out.println(price);
System.out.println("------");
}
/*
* 构造方法也可以重载
*
* 我们就可以在创建对象时，根据构造方法中的参数，决定执行哪个构造方法
*/
public Computer(int a, int b) {
System.out.println("++++++++++");
}
/*
* 再重载三个构造方法
* 测试，创建对象，执行该构造方法
*/
}
package com.qfedu;
public class Demo02 {
public static void main(String[] args) {
/*
* 1. 当我们在一个类中，没有自定义的构造方法
* 那么jdk就会为这个类默认创建一个无参的构造方法
* 如果一旦有自定义的构造方法，那么不在创建默认的构造方法
*/
Phone p = new Phone();
p.brand = "d";
p.price = 2;
p.color = "x";
Phone p2 = new Phone("acer", 3400, "black");
System.out.println(p2.brand);
}
}
class Phone {
String brand;
double price;
String color;
public Phone() {
}
public Phone(String b, double p, String c) {
brand = b;
price = p;
color = c;
}
}
本文含有隐藏内容，请 开通VIP 后查看