一、面向对象概念
面向对象编程: OOP
C语言: 面向过程编程语言
C++语言: 半面向过程半面向对象
Java语言: 完全面向对象编程
面向: 是指针对,关于的意思
面向过程: 针对过程设计代码
举例: 玩五子棋游戏,吃饭
设计棋盘,设计规则,设计棋手,判断胜负
面粉,和面,做面条,做羊肉,下锅,放料,吃
面向对象: 针对对象设计代码
设计棋盘对象, 设计棋手对象
设计厨师对象
面向对象编程,针对对象设计代码,不去过多的考虑细节
面向对象最后,肯定是有面向过程的
二、面向对象编程
面向对象编程OOP
类: java中的类是class,
类是一个统称,是一系列具有相同特征和行为的对象的集合
人类,手机类
特征: 就是属性
属性就是描述类的
人类的特征(属性)
姓名 性别 身高 体重 年龄 国籍 肤色
手机类的特征(属性)
品牌 价格 颜色 内存 电池容量
行为: 就是动作
动作就是功能,即函数.方法
人类的方法(功能,动作)
吃饭,睡觉,工作,学习
手机类的方法(功能,动作)
打电话,发短信,玩游戏,砸核头
对象:
是类的具体体现
人类的对象
现在的同桌
手机类的对象
手里的手机
类,属性,方法,对象 之间的关系
类里面有属性和方法
对象是类创建出来的
对象中拥有具体的属性,能执行的方法
三、第一个类： 人类
java中的类就是class，就是天天见的class，现在创建类的时候要
-
类名 见名知意
-
首字母大写，不要特殊符号，数字不要放开头
public class People{
}类中有属性和方法
-
属性，就是变量，使用 数据类型 属性名；
-
位置： 放在类中，方法外
-
-
方法，就是之前的方法（返回值，方法名，参数）
public class People{
int age;// 年龄属性
String name;// 姓名属性
// 吃饭的方法
public void eat(String food){
System.out.println("吃"+food);
}
}练习: 手机类
属性 价格,颜色,款型
方法: 打电话,玩游戏
public class Phone {
String brand;// 品牌
String color;// 颜色
double price;// 价格
public void call(String num){
System.out.println("给"+num+"打电话" );
}
public String play(String game){
System.out.println("玩 《"+game+"》" );
return "Victory";
}
}四、创建对象
4.1 创建一个对象
类是模板,对象需要由类创建出来,语法
类名 对象名 = new 类名();
为什么创建对象?
因为类是模板,无法使用,需要创建出对象,才能具体体现出属性,以及执行方法
即创建对象的目的是为了使用属性和方法
创建对象
public class Test1OOP {
// 执行代码
public static void main(String[] args) {
// 创建对象的语法
// 类名 对象名 = new 类名();
People people = new People( );
}
}对象使用属性
String name = people.name;
int age = people.age;
String sex = people.sex;
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("sex = " + sex);
// 属性赋值
people.name = "刘备";
people.age = 38;
people.sex = "男";
// 再次取值查看属性
System.out.println(people.name);
System.out.println(people.age);
System.out.println(people.sex);使用方法
people.eat("烩面");
String result = people.sleep( );
System.out.println("睡得如何? " + result );
完整代码
public class Test1OOP {
// 执行代码
public static void main(String[] args) {
People people = new People( );
String name = people.name;
int age = people.age;
String sex = people.sex;
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("sex = " + sex);
// 属性赋值
people.name = "刘备";
people.age = 38;
people.sex = "男";
// 再次取值查看属性
System.out.println(people.name);
System.out.println(people.age);
System.out.println(people.sex);
people.eat("烩面");
String result = people.sleep( );
System.out.println("睡得如何? " + result );
}
}4.2 类创建多个对象
一个类是可以创建多个对象
由类创建出的每个对象中都有属于自己的属性和方法
对象和对象之间的属性和方法互不影响
public static void main(String[] args) {
People p1 = new People( );
p1.name = "刘备";
System.out.println(p1.name );// 刘备
People p2 = new People( );
System.out.println(p2.name );// null
p2.age = 40;
People p3 = new People( );
System.out.println(p3.name );// null
System.out.println(p3.age );// 0
}4.3 多个引用指向同一对象
引用其实就是地址值
通过地址值引用内存中的对象
通过引用传递,将引用地址值赋值给了另外一个变量p2
即p1和p2指向同一个对象
public static void main(String[] args) {
People p1 = new People( );
p1.name = "刘皇叔";
People p2 = p1;
System.out.println(p2.name);// 皇叔
p2.age = 40;
System.out.println(p1.age );// 40
}五、内存图
5.1 创建一个对象的内存图
方法执行进栈
每次new都会进堆,开辟空间,分配地址值
创建对象时,属性会初始化
5.2 创建多个对象图
-
一个类是可以创建多个对象
-
由类创建出的每个对象中都有属于自己的属性和方法
-
对象和对象之间的属性和方法互不影响
5.3 多个引用指向同一个对象
六、成员变量和局部变量
| 成员变量 | 局部变量 | |
|---|---|---|
| 位置 | 类中方法外 | 方法内 |
| 使用范围 | 类中所有方法都可使用 | 只能在当前方法内使用 |
| 初始值 | 在new的时候自动赋默认值 | 手动主动赋值 |
| 内存位置 | 在堆中 | 在栈中的方法栈帧中 |
| 生命周期 | 随着创建对象出现在堆中 随着使用引用被垃圾回收而消失 | 随着方法被调用而进栈出现 随着方法执行完弹栈而消失 |
public class Dog {
String name;// 姓名
int age; // 年龄
String type;// 品种
public void eat(String food){
int num = 2;
// name是使用外部的成名变量
System.out.println(name+"狗吃"+food+",吃了"+num+"份" );
}
public void play() {
// name是使用外部的成名变量
// 成员变量可以被所有方法使用
System.out.println(name+"玩耍" );
}
}特殊情况: 成员变量和局部变量会重名
允许成员变量和局部变量重名
重名时默认使用局部变量, (就近原则)
因为成员变量在堆中,局部变量在方法栈帧,方便调用
当重名时,可以使用this.属性来特指调用成员变量
public void jiao(){
String name = "小黑";
System.out.println(name+"小狗会叫" );
System.out.println(this.name+"小狗会叫" );
System.out.println("this -->" +this );
}
七、构造方法
7.1 什么是构造方法?
构造方法,又称构造函数,又称构造器(constructor)
是类中的一个方法,作用是
用来构造/创建对象
属性赋初始值
无参构造属性初始化默认值
有参构造属性初始化指定值
7.2 怎么写?
构造方法,虽然是方法,但是与之前的方法有些区别
构造方法没有返回值,连void也没有
方法名必须是当前类的类名
public class People{ // 构造方法 public People(){ } // 普通方法 public void eat(){ } }
7.3 如何用?
构造方法的作用是创建对象,当然要在创建对象时使用
创建对象的语法
类名 对象名 = new 类名();
类名 对象名 = new
构造方法();类名 对象名 = new
构造方法(参数1,参数2);
7.4 构造方法特点
每个类默认都有一个无参构造方法,默认是隐藏的
也可以显式的写出
但是,显式的写出任何一个构造方法,默认的构造方法不再提供
7.5 有参构造
但是现在有个问题,通过构造方法创建出的对象的属性都是默认初始值,后续还要自己再单独给属性赋上指定值; 那么能不能像创建数组一样,在创建对象时,直接指定属性,即创建出来的对象属性就有指定值
---> 当然可以,那就是 有参构造方法
有参构造就是有参数的构造方法,目的就是在创建对象时可以指定属性
语法
public People(int age){ this.age = age; }
7.6 有参无参构造的区别
有参构造,无参构造都是为了创建对象
无参构造创建出的对象,属性值是默认值
有参构造创建出的对象,属性值是指定的
八、重载
重载,overload
重载就是在同一类内,方法名一样,参数列表不一样的多个方法
参数列表一样是指,参数的个数,类型,顺序任意不一样都是
重载和返回值没有关系
public class Test2OOP {
public static void main(String[] args) {
System.out.println( );
System.out.println(1);
System.out.println(1.1);
System.out.println("A");
System.out.println(new People( ));
System.out.println(new int[3]);
// =========多个构造方法也是重载关系============
new People( );
new People(19, "关羽");
new People(19);
new People("黄盖");
new People("黄盖",50);
}
/**
* 以下几个都是重载
* 他们的方法名一样,参数的个数,类型,顺序任意不一样都是重载
* 与返回值类没有关系
*/
public static void test() {
}
public static void test(int a) {
}
public static void test(String a) {
}
public static void test(int b, String a) {
}
public static void test(String a, int b) {
}
}People.class中设计重载的构造方法
public class People {
int age;
String name;
/**
* 构造方法没有void,方法名必须是类名
*/
// 无参构造方法,创建对象是默认值
public People(){
}
// 有参构造,调用时传入参数,创建对象出的属性是指定值
public People(int age,String name) {
this.age = age;
this.name = name;
}
public People(String name,int age) {
this.age = age;
this.name = name;
}
public People(int age) {
this.age = age;
}
public People(String name) {
this.name = name;
}
// 普通方法
public void eat(){
System.out.println("人吃饭" );
}
}九、对象创建的过程
调用构造方法创建对象
先对属性初始化
再执行构造方法
package com.qf.pdf.pdf5t8;
class ClassA {
public ClassA() {
System.out.println("ClassA()");
}
}
class ClassB {
public ClassB() {
System.out.println("ClassB()");
}
}
class ClassC {
ClassA a = new ClassA( );
ClassB b;
public ClassC() {
System.out.println("ClassC()");
b = new ClassB( );
}
}
public class TestConstructor {
// main开始执行
public static void main(String args[]) {
// 先调用构造创建对象
/**
* 创建对象的过程
* - 先属性初始化
* - 再执行构造
*/
ClassC cc = new ClassC( );
// 结果是A C B
}
}十、封装
面向对象编程的三个核心知识
封装
继承
多态
5.1 什么是封装?
生活中的封装? 快递封装,将物品封装空间里面
代码的封装?
方法算是封装
类的封装(今天要学的)
主要指的对属性封装
5.2 为什么封装?
快递为例: 封装的目的1)方便传输2)隐藏一些东西
类的封装:
为什么要对属性封装? 可以封装在方法内,可以再方法内实现复杂的逻辑
总结: 隐藏实现的细节,对外提供一些访问的方式
5.3 类如何封装
类的封装,两大步骤
属性私有 --> private修饰属性
提供setXxx,getXxx方法
特殊的,set get方法是固定写法,一定是setXxx getXxx,Xxx是属性名,首字母大写
属性name, ----> void setName(String name){} 返回值 getName(){}
手机类
public class Phone {
private String brand;// 品牌
/**
* private 私有的
* 一旦被private修饰的属性,方法只能在本类中调用
*/
private double price;// 价钱
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand() {
return brand;
}
// 设计方法,给价钱赋值
public void setPrice(double price){
if (price > 0) {
this.price = price;
} else {
System.out.println("设置价钱有误!" );
this.price = 999999999;
}
}
// 设计方法,能获取属性值
public double getPrice() {
return price;
}
public void play() {
System.out.println(price+"元,手机玩游戏");
}
}
扫一扫
1640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
