面向对象的设计思想
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修饰的话,类名和文件名可以不一样,但习惯上,我们都会写上public
1.9 类中成员变量的定义
成员变量:
a.成员变量其实就是全局变量
b.成员变量也被称为属性
c.分为静态变量和非静态变量
d.在静态方法中只能访问静态成员变量,在非静态方法中可以访问非静态成员变量和静态成员变量
成员变量【全局变量】和局部变量的区别:
a.定义的位置不同
成员变量:定义于类中,作用于整个类
局部变量:定义于方法或者语句中,作用于该方法或者该语句。
b.内存中出现的时间和位置不同
成员变量:当对象被创建时,出现在堆内存当中。
局部变量:所属的区间被运算时,出现在栈内存当中。
c.生命周期不同
成员变量:随着对象的出现而出现,随着对象的消失而消失。
局部变量:随着所属区间运算结束,它就被释放。
d.初始化值不同
成员变量:成员变量因为在堆内存当中,所以他有默认的初始值
局部变量:没有默认的初始值
e. 成员变量和局部变量名字相同,局部变量优先级高。就近原则。
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");
}
}
总结:1 静态能访问静态的,不能直接访问非静态的,如果要访问,必须要创建对象。
2非静态的能直接访问非静态的和静态的。
3 如果要访问另外一个类中的静态成员变量和静态方法 类名.静态成员变量 类名.静态方法名
第二节:对象的创建以及内存分析
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~~~~");
}
}
2.2 内存分配
程序运行时,操作系统会分配三块主要的内存空间
-
栈:直接存放基本类型的局部变量,和引用类型的地址
- 栈空间比较小,存取速度相对较快
- 先进后出
-
堆:存放引用类型的实际数据部分
- 堆空间比较大,存取速度相对较慢
-
方法区:(静态区、串池、代码段)方法区中有一块空间叫串池,用来存放字符串常量
2.3 内存分析说明:程序中定义的Person类型的变量实际上是一个引用,它被存放在栈内存中,他指向实际的Person对象,而真正的Person对象则存放于堆内存中
2.4 练习
//测试类
class PracticeDemo01
{
public static void main(String[] args)
{
//需求:开学了,王老师让学生小明,小花,小丽做自我介绍
//姓名,年龄,爱好,来一段才艺展示
/*
老师类
特征:姓名
行为:让学生做自我介绍
*/
//1.创建一个老师的对象
Teacher wang = new Teacher();
wang.name = "王老师";
wang.letStuIntroduce();
}
}
//实体类
//老师类
class Teacher
{
String name;
//参数:学生,Student类型
public void letStuIntroduce() {
Student stu=new Student();
stu.name = "小明";
stu.age = 10;
stu.hobby = "吹牛逼";
stu.introduce();
stu.dance();
stu.sing();
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.构造方法没有返回值类型
d.如果添加了构造方法,系统不再提供默认的构造方法
3.2 构造方法的调用
//演示构造方法的使用
class TextDemo05
{
public static void main(String[] args)
{
//1.系统会默认提供一个无参的构造方法
Animal a = new Animal();
aa.show();
aa.show();
aa.show();
}
}
class Animal
{
//无参的构造方法
//构造方法是在实例化对象的过程中被自动调用的,不需要手动调用
public Animal(){
System.out.println("无参的构造方法被调用");
}
public void show() {
}
}
3.3 构造方法和普通方法的区别
a.构造方法是在创建对象的过程中自动调用的,普通方法只能手动进行调用
b.构造方法没有返回值类型【注意区别返回值void】,普通方法的返回值类型要么是确定的类型,要么为void
c.系统会默认为我们提供一个无参的构造方法,普通方法只能手动添加
d.构造方法的方法名称必须和对应的类名保持一致
e.构造方法在创建对象的过程中就会执行,而且每个对象只执行一次,对于普通方法而言,只有在需要使用的时候才被执行,并且一个对象可以调用多次
注意
a.如果没有写构造方法,系统会默认提供一个无参的构造方法
b.如果手动写构造方法,系统将不再提供无参的构造方法,如果需要使用,则要手动添加(一般情况下,要求将无参的构造方法都写上,哪怕方法里面什么都不写)
3.4 构造方法重载
成员变量默认值:
引用类型:null
基本类型:byte short int :0
long : 0L
float: 0.0f
double:0.0
char :0
boolean:false
//演示构造方法的重载
//测试类
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)
{
//场景:富二代王思聪开着新买的白色宝马在马路上奔跑,很自豪的向他的新女友炫耀
/*
富二代类
特征:姓名 有钱
行为:开车,炫耀
汽车类
特征:颜色,品牌
行为:奔跑
女友类
特征:姓名
*/
//1.创建一个富二代的对象
RichMan wang = new RichMan("王思聪",true);
wang.drive();
wang.show();
}
}
/*
富二代类
特征:姓名 有钱
行为:开车,炫耀车
*/
class RichMan
{
//成员变量
String name;
boolean hasMuchMoney;
//构造方法
public RichMan() {}
public RichMan(String n,boolean is) {
name = n;
hasMuchMoney = is;
}
//成员方法
public void drive() {
Car c=new Car();
c.brand="宝马";
System.out.println(name + "开着豪车" + c.brand);
}
public void show() {
Car c=new Car();
c.brand="宝马";
GirlFriend gf=new GirlFriend();
gf.name="凤姐";
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关键字
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;//年龄
String color;//颜色
//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("带参1构造方法被调用");
}
public Cat(String name,int age,String color) {
//对this()的调用必须是构造方法中的第一个语句
//this();
//具体调用的是哪个构造方法,取决于所传的参数
this(name,age);
this.color = color;
System.out.println("带参2构造方法被调用");
}
//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;
}
}