java学习--day8 （面向对象）

回顾

1.选择排序
	原理: 找到最小值的下标，交换
2.冒泡排序
	原理: 比较相邻的两个元素，把最小值放到左边。第一次比较的时候最大值放到最右边了，以此类推
1
2
3
4

今天的内容

1类和对象

2.类和对象内存

3.构造方法

1.从生活的角度区理解面向对象开发

有两种编程思想:

​ 面向过程：

​ 程序自上而下执行，不牵涉到类和对象的操作。本质是代码自己完成自己的功能

​ 冒泡排序是面向过程的

​ 亲力亲为 都是面向过程的

​ 面向对象:

​ 程序是靠对象完成一定的功能

​ Arrays.sort(arr) 这个就是面向对象的

​ 借助于对象来实现功能的

2.面向对象两个重要概念

类: 是对一切相似事物的统称。是一个泛泛的概念。可以用来描述事物的特征和行为的

对象:是一个具体的实体。是这是真实存在的。在类的基础之上孵化出来的。

特征：就是一类事物的属性，比如人的年龄  身高 体重  性别
	在Java代码中使用变量来表示一个类的特征或者属性
	int age;
	double height;
	是静的东西
行为:就是动作  吃饭 睡觉  敲代码
	在Java中使用方法来描述一个类的行为
	是动的东西
1
2
3
4
5
6
7
8

只要注意好特征和行为就可以写好一个类了。

人类:
	特征，又叫属性:
		名字 性别 身高  体重
	行为,又叫方法:
		吃饭  睡觉 敲代码
1
2
3
4
5

3.声明一个类

语法格式:

[public] class 类名 {
	对于当前类的属性的描述
	对于当前类的行为的描述
}
1
2
3
4

package com.qfedu.a_class;

 class Person {
	 //人类:
	 	//属性: 姓名  年龄  性别  身高
	 	//行为: 吃饭  睡觉
	//类下面的属性:  Java使用变量来描述
	 //在类中 变量最好不要赋值
	 String name; //名字  null
	 int age;//年龄  0
	 char sex;//性别 
	 double height;//身高0.0
	 //在类中后书写行为  Java使用方法来描述行为
	 //public static void eat() {}
	 //今天学的内容，和之前方法的声明不一样，去掉static即可
	 public void  eat () {
		 
		 System.out.println("中午吃酸菜鱼");
	 }
	 public void sleep () {
		 System.out.println("中午不睡，下午崩溃");
	 }
	 
	 
	 
	 
	 
	 	
	 

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

案例:

​ 狗类:

​ 属性: 名字 毛色 品种 性别

​ 行为: 看家 打架

package com.qfedu.a_class;

public class Dog {
	String name;//声明的狗的名字
	String color;//代表的是狗毛色
	String kind;//代表狗的品种
	boolean sex;//性别
	
	//定义方法
	public void lookHome () {
		System.out.println("狗汪汪叫，在看家");
	}
	public void fight () {
		System.out.println("狗咬狗,一嘴毛");
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

案例：

​ 猪类:

​ 属性和方法自己想

4.对象的创建

一个类声明好以后，不使用它，它是一直存在，咱们可以借助于对象衍生出一个实体。

类可以衍生出来一个对象。类相当于一个模子。可以造出来一个实体。

造出对象的目的是为了啥? 就是执行属性的复制和方法的调用的

先有类，再有对象

对象的创建在main主函数中。目的是为了执行这个对象代码

Java语法格式:

类名  对象的名字 = new 类名();
1

package com.qfedu.a_class;

//Demo1叫测试类  里面有main主函数
public class Demo1 {
	public static void main(String[] args) {
		//类名  对象的名字 = new  类名();
		//这个对象是由类衍生出来的，就意味着类下面的属性可以使用
		//类下面的方法我可以调用
		Person person = new Person();
		//对属性进行赋值
		//person的名字 为 狗蛋
		person.name = "狗蛋";
		person.age = 78;
		person.sex = '男';
		person.height = 98.7;
		//以上是对对象的属性进行赋值
		//将对象的属性值取出来
		System.out.println(person.name + person.age + person.sex + person.height);
		//方法的调用  对象.方法名字();
		person.eat();
		person.sleep();
		
		Person person1 = new Person();
		person1.name = "二狗";
		person1.age = 12;
		person1.sex = '男';
		person1.height = 178;
		System.out.println(person1.name + person1.age + person1.sex + person1.height);
		person1.eat();
		person1.sleep();
		
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

案例:

​ 之前写过一个Dog类。现在开始通过Dog类创建dog对象，可以创建多个的

package com.qfedu.a_class;

public class Demo2 {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.name = "";
		dog.color = "花色";
		dog.kind = "金毛";
		dog.sex = true;
		System.out.println(dog.name + dog.color + dog.sex + dog.kind);
		dog.fight();
		dog.lookHome();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

咱们现在实体类和测试类写在了不同的Java文件中。

5.创建的实体类和测试类在同一个Java文件中

文件的名字以测试类来命名

package com.qfedu.a_class;

//注意事项:实体类和测试类写在同一个文件中的时候，实体类不能带public修饰符
class Pig {
	String name;
	double weight;//体重
	char sex;//性别
	
	public void eat () {
		System.out.println("猪吃白菜！！！");
	}
	public void sleep () {
		System.out.println("猪睡觉打呼噜");
	}
}
 class Demo3 {
	public static void main(String[] args) {
		//创建对象
		Pig pig = new Pig();
		pig.name = "大黄";
		pig.weight = 100.1;
		pig.sex = '公';
		System.out.println(pig.name + pig.weight + pig.sex);
		pig.eat();
		pig.sleep();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

练习 :

​ 羊类 龙类 老鼠 鸡

​ 属性和方法自己声明，创建对象对属性进行赋值和方法调用。

​ 写在同一个文件中！！！

上午的内容

1.会新建一个类
2.会通过类创建一个对象 并对对象的属性进行赋值   对象还可以调用类下面的方法

1
2
3

6.构造方法

构造方法的目的是为了初始化对象的，换句话说，可以对对象的属性进行赋值

对象创建其实是依据构造方法创建的！！！【重点】

6.1无参构造方法

构造方法必须写在实体类中

语法格式:

public 类名() {

}
1
2
3

package com.qfedu.b_constructor;

class Dog {
	String name;
	int age;
	public Dog () {
		System.out.println("嘻嘻哒");
		name = "大黄";
		age = 12;
	}
	
}
public class Demo2 {
	public static void main(String[] args) {
		//当new Dog()的时候就会去自动调用无参构造方法去执行无参构造方法中的方法体
		Dog dog = new Dog();
		dog.name = "旺财";
		dog.age = 3;
		//打印的是旺财和3 为啥没有打印大黄和12 因为无参构造先执行了
		//后面赋的值就会覆盖掉初始化的值
		System.out.println(dog.name);
		System.out.println(dog.age);
		
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6.2有参构造

语法格式:

public 类名 (参数) {
	初始化条件;
}
1
2
3

package com.qfedu.b_constructor;

class Cat {
	String name;
	String kind;
	int age;
	
	public Cat() {
		
	}
	//和下面的有参构造一模一样！！！
//	public Cat (String kind) {
//		this.kind = kind; 
//	}
	//声明一个有参构造方法
	public Cat (String name) {
		this.name = name;
	}
	//带有三个参数 构造方法
	public Cat (String name, String kind, int age) {
		this.name = name;
		this.age = age;
		this.kind = kind;
	}
	
	
}
public class Demo3 {

	public static void main(String[] args) {
		Cat cat = new Cat("狗蛋");
		
		System.out.println(cat.name);
		//new对象的时候依据构造方法来创建对象
		Cat cat1 = new Cat("毛蛋", "波斯", 3);
		System.out.println(cat1.name);
		System.out.println(cat1.age);
		System.out.println(cat1.kind);
		//一旦写了有参构造方法以后，默认的无参构造方法就没有了
		Cat cat2 =  new Cat();
		cat2.name = "Tom";
		cat2.age = 4;
		cat2.kind = "蓝猫";
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

案例:

猴子类:

​

package com.qfedu.b_constructor;

class Monkey {
	String name;
	int age;
	double weight;
	
	public Monkey (String name, int age, double weight) {
		this.name = name;
		this.age = age;
		this.weight = weight;
	}
	
	
}
public class Demo4 {
	public static void main(String[] args) {
		Monkey monkey = new Monkey("弼马温", 3, 98.7);
		//不让你使用对象.变量 = 初始化的值; 这种方式对属性进行赋值了
		//换一种方式赋值。叫有参构造
//		monkey.name = "孙悟空";
//		monkey.age = 500;
//		monkey.weight = 89;
		System.out.println(monkey.name);
		System.out.println(monkey.age);
		System.out.println(monkey.weight);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

7.对象在内存中如何存储的

栈内存：

​ 存的是八大基本数据类型的数据

​ 对象的引用。 =左边

堆内存:

​ 对象的全部数据

8.构造代码块【了解】

开发中已经不用了

以后会讲静态代码块。

构造代码块的目的也可以对咱们的对象进行初始化的。功能和构造方法一样的

语法格式:

{
	语句体
}
1
2
3

注意事项:

​ 1.构造代码块必须写在实体类中

​ 2.先执行的是构造代码块，再执行构造方法

package com.qfedu.b_constructor;

class Tiger {
	String name;
	int age;
	
	
	//再声明一个构造方法
	public Tiger () {
		this.name = "haha";
		System.out.println("我是无参构造方法");
	}
	//先写一个构造代码块
		{
			this.name = "嘻嘻";
			System.out.println("我是构造代码块");
		}
}
public class Demo5 {
	public static void main(String[] args) {
		//先执行实体类中构造代码块 然后再执行构造方法
		Tiger tiger = new Tiger();
		System.out.println(tiger.name);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

9.局部变量和成员变量

9.1局部变量

局部变量就是变量的作用域，其实是已经见过局部变量

package com.qfedu.c_var;

import org.omg.CORBA.PUBLIC_MEMBER;

public class Demo1 {

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			//上面的i就是for循环的局部变量，出了for循环还能用吗？不能
			//紧紧围绕着一个东西就是那个大括号
			System.out.println(i);
		}
		//System.out.println(i);
		if (3 < 4) {
			int i = 98;
			
		}
	
	}
	public static void test () {
		int i = 20;
		System.out.println(i);
	}
	public static void test1 () {
		//System.out.println(i);
	}
	//总结一下: 一定要看清大括号里面的那个变量只能在大括号里面来使用的
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

9.2成员变量

定义在实体类中的大括号的后面，又叫属性

String name;

int age;

package com.qfedu.c_var;

class Person {
	//name 和 age都是成员变量
	String name;
	int age;
	//作用域 是作用再整个类中 的，只要在类中都可以使用当前的成员变量
	
	public void eat () {
		double weigt;//局部的变量
		System.out.println(name + age);
	}
}
public class Demo2 {
	public static void main(String[] args) {
		
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

9.3局部和成员变量的区别

总结：

1.会声明一个类
2.会创建一个对象
3.会对对象的属性进行赋值
4.会对对象的方法进行调用
5.构造方法的声明
	有一些细节一定要关注
	构造方法是初始化对象的
	
6.构造代码块
7.局部变量和成员变量
1
2
3
4
5
6
7
8
9
10