面向对象
回顾
今天任务
1. 面向对象
2. 面向过程
3. 类的创建
4. 对象的创建
5. 对象创建内存分析
6. 构造方法
7. this关键字教学目标
1. 掌握面向对象思想
2. 掌握类和对象的创建
3. 掌握对象创建内存分析
4. 掌握构造方法
5. 掌握this关键字第一节 ： 面向对象的设计思想
1.1 什么是面向对象
一种看待问题的思维方式，着眼于找到一个具有特殊功能的具体个体，然后委托这个个体去做某件事情，我们把这个个体就叫做对象
是一种更符合人类思考习惯的思想【懒人思想】，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者
使用面向对象进行开发，先要去找具有所需功能的对象来用，如果该对象不存在，那么创建一个具有所需功能的对象1.2 面向过程
一种看待问题的思维方式，在思考问题的时候，着眼于问题是怎样一步一步解决的，然后亲力亲为的去解决问题1.3 面向对象和面向过程的对比
面向对象是基于万物皆对象这个哲学观点
举例说明：
案例一：我想要吃大盘鸡 面向过程 面向对象 1.自己去买菜 1.委托一个会砍价的人帮忙去买菜 2.自己择菜 2.委托一个临时工帮忙择菜 3.自己做菜 3.委托一个厨师帮忙做菜 4.自己开始吃 4.自己开始吃
案例二：小明是一个电脑小白，想要配一台电脑，买完零件后需要运到家里，组装完成后打开电脑玩游戏 面向过程 面向对象 1.小明补充电脑知识 1.委托一个懂电脑的朋友(老王)去帮忙买零件 2.小明去买零件 2.委托一个能跑腿的人去买零件 3.小明把零件带回家里 2.委托一个快递小哥帮小明送到家里 4.小明组装电脑 3.委托一个会组装电脑的人帮小明组装电脑 5.小明开机玩电脑 4.小明自己打开电脑，开始玩游戏
1.4 区别总结
a.都是看待问题的一种思维方式，都能解决问题
b.面向过程着眼于所有的事情亲力亲为
c.面向对象着眼于找到一个具有特殊功能的对象，委托这个对象帮忙去做某件事情
注意：面向对象时一种思想，并不是一门编程语言1.5 类的定义
一个具有特殊功能的实体的集合【群体】，类是Java语言的最基本单位1.6 对象的定义
在一个类中，一个具有特殊功能的实体，能够帮忙解决特定的问题，对象也被称为实例1.7 类与对象之间的关系
a.类是对象的抽象,对象是类的具体体现
b.Java中描述事物通过类的形式体现,类是具体事物的抽象,对象即是该类事物实实在在的个体1.8 类的声明
语法：访问权限修饰符 class 类名 {
//类体 }
说明：a.访问权限修饰符：只能是public(可以被省略，省略后为default) b.类名只要是一个合法的标识符即可，但是要求：首字母必须大写，遵循驼峰命名法 c.尽量使用单个或多个有意义的单词连接而成 public class FirstDemo {
}
注意：a.一个Java文件中可以写多个类，如果写多个类，则编译后会生成多个.class文件 b.一个Java文件中最多只能有一个被public修饰的类，这个类的类名必须和Java源文件名保持一致 c.一个Java文件中如果只有一个类，并且这个类不用public修饰的话，类名和文件名可以不一样，但习惯上，我们都会写一样
1.9 类中成员变量的定义
成员变量：
a.成员变量其实就是全局变量
b.成员变量也被称为属性 c.分为静态变量和非静态变量 d.在静态方法中只能访问静态成员变量，在非静态方法中可以访问非静态成员变量和静态成员变量
成员变量【全局变量】和局部变量的区别： a.定义的位置不同
成员变量：定义于类中，作用于整个类 局部变量：定义于方法或者语句中，作用于该方法或者该语句。
b.内存中出现的时间和位置不同
成员变量：当对象被创建时，出现在堆内存当中。 局部变量：所属的区间被运算时，出现在栈内存当中。
c.生命周期不同
成员变量：随着对象的出现而出现，随着对象的消失而消失。 局部变量：随着所属区间运算结束，它就被释放。
d.初始化值不同
成员变量：成员变量因为在堆内存当中，所以他有默认的初始值 局部变量：没有默认的初始值
1.10 类中方法的定义
a.分为静态方法和非静态方法
b.在同一个类中，在静态方法中只能调用静态方法，在非静态方法中可以调用非静态方法和静态方法
class TextDemo01
{
//定义非静态全局变量
String str;
//定义静态全局变量
static int num;
//main是静态函数
public static void main(String[] args)
{
show();
//结论一：在同一个类中，在静态函数中不能调用非静态函数
// 错误: 无法从静态上下文中引用非静态 方法 display()
//display();
//结论三：在同一个类中，在静态函数中只能访问静态全局变量
// 错误: 无法从静态上下文中引用非静态 变量 str
//System.out.println(str);
System.out.println(num);//0
//定义一个局部变量
//当全局变量和局部变量重名的时候，访问的时候采用就近原则
//尽量避免全局变量和局部变量重名
int num = 10;
System.out.println(num);
}
//静态函数
public static void show() {
System.out.println("show");
}
//非静态函数
public void display() {
System.out.println("display");
//结论二：在同一个类中，非静态函数可以调用静态函数，也可以调用非静态函数
show();
display11();
//结论四：在同一个类中，非静态函数可以访问静态全局变量以及非静态全局变量
System.out.println(str);
System.out.println(num);
}
//非静态函数
public void display11() {
System.out.println("display11");
}
}第二节：对象的创建以及内存分析
2.1 对象的创建
对象的创建过程也被称为对象的实例化过程
语法：类名 标识符 = new 类名();
//演示对象的创建，跨类进行调用成员方法以及访问成员变量
//测试类：含有main函数得类被称为测试类
public class TextDemo01
{
public static void main(String[] args)
{
//1.创建对象
//语法:类名 变量名称 = new 类名();
Person xiaoMing = new Person();
//2.调用其他类中的非静态方法和访问其他类中非静态成员变量
//语法：对象.
System.out.println(xiaoMing.name);
//虽然是跨类进行访问，Person类中成员变量仍然是一个变量，值可以随时发生改变
xiaoMing.name = "小明";
System.out.println(xiaoMing.name);
xiaoMing.age = 10;
xiaoMing.gender = 'B';
xiaoMing.eat();
//3.调用其他类中的静态方法和访问其他类中静态成员变量
//语法：对象. 类名.
System.out.println(Person.country);
Person.country = "中国";
System.out.println(Person.country);
Person.run();
xiaoMing.country = "China";
System.out.println(Person.country);
System.out.println(xiaoMing.country);
xiaoMing.run();
//4.同一个类可以创建多个对象
Person xiaoLi = new Person();
}
}
//实体类：表示具有某些特征或者某些行为的类
//描述多个对象所具有的共同特征和共同行为
//需求：人类，具有姓名，年龄，性别等的特征，可以吃东西，可以奔跑，，，，
class Person
{
//第一部分
//成员变量：特征【名词】
//非静态成员变量
String name;//null
int age;//0
char gender;//\u0000
//静态成员变量
static String country;//null
//第二部分
//成员方法：行为【动词】
//非静态成员方法
public void eat() {
System.out.println("eating~~~~");
}
//静态成员方法
public static void run() {
System.out.println("running~~~~");
}
}总结：a.静态方法和静态成员变量都是属于类的，需要访问的时候用: 类名. 的方式来访问
b.非静态方法和非静态成员变量是属于对象的，需要访问的时候用: 对象. 的方式来访问 c.开辟空间的时机不同
2.2 内存分析
中
说明：程序中定义的Person类型的变量实际上是一个引用，它被存放在栈内存中，他指向实际的Person对象，而真正的Person对象则存放于堆内存中
2.3 练习
//测试类
class PracticeDemo01
{
public static void main(String[] args)
{
//需求：开学了，王老师让学生小明，小花，小丽做自我介绍
//姓名，年龄，爱好，来一段才艺展示
/*
老师类
特征：姓名
行为：让学生做自我介绍
学生类
特征：姓名，年龄，爱好
行为：才艺展示
*/
//1.创建一个老师的对象
Teacher wang = new Teacher();
wang.name = "王老师";
//2.创建一个学生对象
Student xiaoming = new Student();
//赋值
xiaoming.name = "小明";
xiaoming.age = 10;
xiaoming.hobby = "吹牛逼";
//3.老师执行自己的行为
wang.letStuIntroduce(xiaoming);
Student xiaohua = new Student();
//赋值
xiaohua.name = "小花";
xiaohua.age = 10;
xiaohua.hobby = "唱歌";
wang.letStuIntroduce(xiaohua);
}
}
//实体类
//老师类
class Teacher
{
String name;
//参数：学生，Student类型
public void letStuIntroduce(Student stu) {
System.out.println(name + "让学生" + stu.name + "做自我介绍");
stu.introduce();
if(stu.name.equals("小丽")) {
stu.dance();
} else if(stu.name.equals("小花")) {
stu.sing();
} else {
stu.lie();
}
}
}
//学生类
class Student
{
String name;
int age;
String hobby;
public void introduce() {
System.out.println("我是" + name + "今年" + age + "爱好：" + hobby);
}
public void dance() {
System.out.println("跳一段广场舞");
}
public void sing() {
System.out.println("来一段freeStyle");
}
public void lie() {
System.out.println("吹个牛逼");
}
}第三节：构造方法的定义
3.1 构造方法的定义
构造方法也叫构造器，是指当实例化一个对象（创建一个对象）的时候，第一个被调用的方法
语法：访问权限修饰符 类名() { //方法体 }
普通方法： 访问权限修饰符 其他的修饰符 返回值类型 函数名（参数列表） {
}
说明：a.构造方法是在实例化对象的过程中自动调用的
b.系统会默认为我们提供一个无参的构造方法 c.构造方法没有返回值类型
3.2 构造方法的调用
//演示构造方法的使用
class TextDemo05
{
public static void main(String[] args)
{
//1.系统会默认提供一个无参的构造方法
Animal a = new Animal();
Animal aa = new Animal("fadhbf");
aa.show();
aa.show();
aa.show();
}
}
class Animal
{
//无参的构造方法
//2.构造方法是在实例化对象的过程中被自动调用的，不需要手动调用
public Animal(){
System.out.println("无参的构造方法被调用");
}
//3.当手动添加一个有参的构造方法之后，系统将不再提供无参的构造方法
//如果要使用无参的构造方法，只能手动添加
public Animal(String str) {
System.out.println("String构造方法被调用");
}
public void show() {
}
}3.3 构造方法和普通方法的区别
a.构造方法是在创建对象的过程中自动调用的，普通方法只能手动进行调用 b.构造方法没有返回值类型【注意区别返回值void】，普通方法的返回值类型要么是确定的类型，要么为void c.系统会默认为我们提供一个无参的构造方法,普通方法只能手动添加 d.构造方法的方法名称必须和对应的类名保持一致 e.构造方法在创建对象的过程中就会执行，而且每个对象只执行一次，对于普通方法而言，只有在需要使用的时候才被执行，并且一个对象可以调用多次
注意 a.如果没有写有参的构造方法，系统会默认提供一个无参的构造方法 b.如果手动写了有参的构造方法，系统将不再提供无参的构造方法，如果需要使用，则要手动添加（一般情况下，要求将无参的构造方法都写上，哪怕方法里面什么都不写）
3.4 构造方法重载
//演示构造方法的重载
//测试类
class TextDemo06
{
public static void main(String[] args)
{
//直接赋值
/*
Dog maomao = new Dog();
maomao.name = "毛毛";
maomao.age = 3;
maomao.lookHome();
*/
//通过构造方法赋值
Dog dahuang = new Dog("大黄",5);
dahuang.lookHome();
}
}
//实体类
class Dog
{
//成员变量
String name;
int age;
//构造方法
public Dog() {}
//有参的构造方法，参数一般设置为和成员变量有关的参数
public Dog(String n,int a) {
//给成员变量赋值
name = n;
age = a;
}
/*
public Dog(String n) {
name = n;
}
*/
//成员方法
public void lookHome() {
System.out.println(name + "看家");
}
}3.5 练习
//测试类
class PracticeDemo02
{
public static void main(String[] args)
{
//场景：富二代王s聪开着新买的白色宝马在马路上奔跑，很自豪的向他的新女友炫耀
/*
富二代类
特征：姓名 有钱
行为：开车，炫耀
汽车类
特征：颜色，品牌
行为：奔跑
女友类
特征:姓名
*/
//1.创建一个富二代的对象
RichMan wang = new RichMan("王思聪",true);
//2.创建一个汽车的对象
Car BMW = new Car("白色","兰博基尼");
//3.创建一个女友的对象
GirlFriend girl = new GirlFriend("凤姐");
//4.让富二代执行自己的行为
wang.drive(BMW);
//wang.show(girl,BMW);
}
}
/*
富二代类
特征：姓名 有钱
行为：开车，炫耀车
*/
class RichMan
{
//成员变量
String name;
boolean hasMuchMoney;
//构造方法
public RichMan() {}
public RichMan(String n,boolean is) {
name = n;
hasMuchMoney = is;
}
//成员方法
public void drive(Car c) {
System.out.println(name + "开着豪车" + c.brand);
}
public void show(GirlFriend gf,Car c) {
System.out.println(name + "向" + gf.name + "炫耀豪车" + c.brand);
}
}
/*
汽车类
特征：颜色，品牌
行为：奔跑
*/
class Car
{
//成员变量
String color;
String brand;
//构造方法
public Car() {}
public Car(String c,String b) {
color = c;
brand = b;
}
//成员方法
public void run() {
System.out.println("一辆" + color + "的" + brand + "在奔跑");
}
}
/*
女友类
特征:姓名
*/
class GirlFriend
{
//成员变量
String name;
//构造方法
public GirlFriend(){}
public GirlFriend(String n) {
name = n;
}
}第四节：this关键字
4.1 this.属性
访问本类的成员属性
作用：为了区分成员变量和形参
4.2 this.方法
访问本类的成员方法
4.3 练习
//演示this的使用
class ThisUsageDemo01
{
public static void main(String[] args)
{
//
Cat maomao = new Cat("毛毛",10);
maomao.setName("fhsdg");
Cat xiaohei = new Cat("小黑",5);
xiaohei.setName("hello");
/*
无参的构造方法被调用
String int构造方法被调用
无参的构造方法被调用
String int构造方法被调用
说明：每创建一个对象，只能自动的调用其中的一个构造方法，通过this()可以手动的去调用其他的构造方法
*/
//对象.
xiaohei.show3();
}
}
class Cat
{
String name;
int age;
int num;
int num1;
//3.this()
public Cat() {
System.out.println("无参的构造方法被调用");
}
//1.this.属性
public Cat(String name,int age) {
//调用的是无参的构造方法
this();
this.name = name;
this.age = age;
System.out.println("String int构造方法被调用");
}
public Cat(String name,int age,int num,int num1) {
//对this()的调用必须是构造方法中的第一个语句
//this();
//具体调用的是哪个构造方法，取决于所传的参数
this(name,age);
//可以简化代码
//this.name = name;
//this.age = age;
this.num = num;
this.num1 = num1;
System.out.println("String int int int构造方法被调用");
}
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;
}
//2.this.方法
//普通方法
public void show1() {
//在本类中调用方法时，this可以省略
this.show2();
//在非静态方法中调用静态方法时，也可以使用this，this同样可以省略
this.show3();
}
public void show2() {
}
//静态方法
public static void show3() {
//错误: 无法从静态上下文中引用非静态 变量 this
//在静态方法中不能使用this
/*
在测试类中的main函数使用xiaohei调用了show3方法，所以此处的this代表的就是xiaohei
而xiaohei本身是一个引用性的变量，是非静态的，所以在静态函数中不能访问非静态变量
*/
//this.show4();//错误演示
show4();
}
public static void show4() {
}
}4.4 this()
访问本类中的构造函数
注意：
a.必须出现在构造方法中 b.访问的是除了当前构造方法之外的其他构造方法 c.具体访问的是哪个构造方法，取决于所传的参数 d.只能书写在构造方法的第一条语句 e.this()在同一个构造方法中只能出现一次
class ThisUsageDemo02
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
class Dog
{
String name;
int age;
int num;
String hobby;
//提高代码的可读性，可维护性
//构造方法
public Dog() {
}
public Dog(String name) {
this.name = name;
}
public Dog(int age) {
this.age = age;
}
public Dog(String name,int age) {
this.name = name;
this.age = age;
}
public Dog(String name,int age,int num,String hobby) {
this(name,age);
this.num= num;
this.hobby = hobby;
}
}第五节：总结
第六节： 课前默写
1.使用Arrays工具类完成下面操作
使用静态初始化的方式初始化一个一维数组
升序排序 实现二分法查找 将数组转化为字符串表示形式
遍历出所有的元素
2.使用不定长参数自定义一个函数，函数主体部分实现只打印偶数的功能
第七节：作业
利用面向对象的思想写下面的程序
1.小美在朝阳公园溜旺财【注：旺财是狗】
2.小明穿着白色的特步运动鞋在奥林匹克公园跑步
3.赵老师在讲台上讲课，小刚认真的听课做笔记
4.张阿姨和李阿姨在物美超市买红富士
构造方法
1.定义一“圆”（Circle）类，圆心为“点”Point类，构造一圆，求圆的周长和面积，并判断某点与圆的关系
2.李晓在家里开party，向朋友介绍家中的黄色的宠物狗【彩彩】具有两条腿走路的特异功能。
3.王梅家的荷兰宠物猪【笨笨】跑丢了，她哭着贴寻猪启示。
4.富二代张三向女朋友李四介绍自己的新跑车：白色的宾利
第八节：面试题
1.什么是面向对象？面向对象和面向过程的区别是什么
面向对象是基于面向对象的编程思想
面向过程强调的是每一个功能的实现，面向对象强调的是对象，然后用对象去调用功能。
2.构造方法与普通方法之间的区别
构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
3.this关键字的作用以及使用