黑马程序员-面向对象基础知识1

第一讲 面向对象概述

1:面向对象思想

面向对象是基于面向过程的编程思想。

面向过程:强调的是每一个功能的步骤
面向对象:强调的是对象,然后由对象去调用功能

2:面向对象的思想特点
A:是一种更符合我们思想习惯的思想
B:可以将复杂的事情简单化

C:将我们从执行者变成了指挥者

3:开发,设计,特征
面向对象开发
就是不断的创建对象,使用对象,指挥对象做事情。

面向对象设计
其实就是在管理和维护对象之间的关系。

面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

第二讲 类与对象

1.类与对象

类:是一组相关的属性和行为的集合。是一个抽象的概念。

属性就是在类中的成员变量,行为就是类中的成员方法
对象:是该类事物的具体表现形式。具体存在的个体。

如:我现在定义一个学生类

学生有姓名、年龄和地址,将这三个属性定义为成员变量

学生有学习、吃饭和睡觉,将这三个属性定义为成员方法

/这是我的学生类
class Student {
	//定义变量
	//姓名
	String name;
	//年龄
	int age;
	//地址
	String address;
	
	//定义方法
	//学习的方法
	public void study() {
		System.out.println("学生爱学习");
	}
	
	//吃饭的方法
	public void eat() {
		System.out.println("学习饿了,要吃饭");
	}
	
	//睡觉的方法
	public void sleep() {
		System.out.println("学习累了,要睡觉");
	}
}

对于这个类的测试就是创建这个类的对象,并验证里面的方法和属性

//这是学生测试类
class StudentDemo {
	public static void main(String[] args) {
		//类名 对象名 = new 类名();
		//创建一个对象
		Student s = new Student();
		
		//输出成员变量值
		System.out.println(s.name+"---"+s.age+"---"+s.address);
		
		
		//给成员变量赋值,即对属性进行修改
		s.name = "林青霞";
		s.age = 27;
		s.address = "北京";
		//赋值后的输出
		System.out.println(s.name+"---"+s.age+"---"+s.address);
		
		//调用成员方法
		s.study();
		s.eat();
		s.sleep();
	}
}
2.成员变量与局部变量

我们之前没有学面向对象时使用的变量基本上都是局部变量

成员变量和局部变量的区别?
A:在类中的位置不同
成员变量:在类中方法外
局部变量:在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存
C:生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
D:初始化值不同
成员变量:有默认初始化值
局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。

注意事项:
局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
3.形式参数问题

基本类型:形式参数的改变不影响实际参数,因为为基本类型时,调用时是直接复制,不会影响实际参数
引用类型:形式参数的改变直接影响实际参数,因为为引用类型时,调用的是引用类型的地址,所以对于参数的操作直接影响到实际参数

4.匿名对象

匿名对象:就是没有名字的对象。如: new Student();

匿名对象的应用场景:
A:调用方法,仅仅只调用一次的时候。
注意:调用多次的时候,不适合。
那么,这种匿名调用有什么好处吗?
有,匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递

注:如果对一个对象进行多个成员调用,必须给这个对象起个名字。

5.封装和private关键字

private:
是一个权限修饰符
可以修饰成员变量和成员方法
被其修饰的成员只能在本类中被访问

封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

封装和private的应用:

A:把成员变量用private修饰
B:提高对应的getXxx()和setXxx()方法

示例:

//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String n) {
		name = n;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄赋值
	public void setAge(int a) {
		age = a;
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//使用成员变量
		//错误:被私有修饰了,外界不能直接访问了
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//给成员变量赋值
		//s.name = "xxx";
		//s.age = 27;
		//通过方法给赋值
		s.setName("xxx");
		s.setAge(27);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}


6.this关键字

this:是当前类的对象引用。简单的记,它就代表当前类的一个对象。

注意:谁调用这个方法,在该方法内部的this就代表谁。

this的场景:
解决局部变量隐藏成员变量

//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String name) { //局部变量时name,成员变量也是name  
		this.name = name;//this能够很好区分
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄赋值
	public void setAge(int age) {
		this.age = age;
	}
}


7.构造方法

构造方法作用:
给对象的数据进行初始化
格式:
A:方法名与类名相同
B:没有返回值类型,连void都没有
C:没有具体的返回值

构造方法的注意事项:
A:如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
B:如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法

给成员变量赋值有两种方式:
A:setXxx()
B:构造方法

构造代码块
       作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数运行。
和构造函数的区别:
       构造代码块是给所有对象进行初始化。
       而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的初始化内容。


8.static关键字

为什么会有static关键字?

static是一个修饰符,用于修饰成员(成员变量和成员函数)。
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用。
格式:类名.静态成员。

static的特点:(它可以修饰成员变量,还可以修饰成员方法)
A:随着类的加载而加载
回想main方法。
B:优先于对象存在
C:被类的所有对象共享
举例:咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的,那么它就应该定义为静态的。
举例:
饮水机(用静态修饰)
水杯(不能用静态修饰)
D:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。

静态修饰的内容一般我们称其为:与类相关的,类成员


static关键字注意事项
A:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载,this是随着对象的创建而存在。
静态比对象先存在。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法:
成员变量:只能访问静态变量
成员方法:只能访问静态成员方法
非静态方法:
成员变量:可以是静态的,也可以是非静态的
成员方法:可是是静态的成员方法,也可以是非静态的成员方法。
简单记:
静态只能访问静态。

9.不同代码块

代码块:在Java中,使用{}括起来的代码被称为代码块。

静态代码块:
       格式:
              static
              {
                           静态代码块中的语句。
              }
特点:随着类的加载而执行,执行一次。并优先于主函数。用于给类进行初始化。


根据其位置和声明的不同,可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前,都会先执行构造代码块。
作用:可以把多个构造方法中的共同代码放到一起,对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用:一般是对类进行初始化。

示例:

class Code {
	static {
		int a = 1000;
		System.out.println("静态代码块" + a);
	}

	// 构造代码块
	{
		int x = 100;
		System.out.println("构造代码块" + x);
	}

	// 构造方法
	public Code() {
		System.out.println("构造方法" + "code");
	}

	// 构造方法
	public Code(int a) {
		System.out.println("构造方法" + "code" + a);
	}

	// 构造代码块
	{
		int y = 200;
		System.out.println("构造代码块" + y);
	}

	// 静态代码块
	static {
		int b = 2000;
		System.out.println("静态代码块" + b);
	}
}

class CodeDemo {
	public static void main(String[] args) {
		// 局部代码块
		{
			int x = 10;
			System.out.println("局部代码块" + x);
		}

		{
			int y = 20;
			System.out.println("局部代码块" + y);
		}
		System.out.println("---------------");

		Code c = new Code();
		System.out.println("---------------");
		Code c2 = new Code();
		System.out.println("---------------");
		Code c3 = new Code(1);
	}
}



静态代码块,构造代码块,构造方法的执行顺序:

静态代码块 -- 构造代码块 -- 构造方法
静态代码块:只执行一次
构造代码块:每次调用构造方法都执行

执行结果:





评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值