Java基础_8类-对象-构造方法【重点】

今天的内容

1.类和对象

2.构造方法【重点】

1.面向过程和面向对象的编程思想

两种编程思想：

​ 面向过程: 写的冒泡排序 选择排序都是面向过程

​ 面向对象: Arrays.sort(arr)

2.面向对象的两个概念

类: 是对一起相似事物的统称。是一个泛泛的概念。

​ 可以用来描述事物的特征和行为。

对象: 就是一个具体的实体。是真实存在的 。是靠类来衍生出来。

特征: 就是一类事物的属性，比如 人的年龄  身高 体重   等  是静的
行为: 就是动作  比如 吃饭  睡觉  打豆豆 等  是动的

类:
	属性:在Java中使用变量描述属性
	行为:在Java中使用方法描述行为

3.声明一个类

语法格式:

[public] class  类名 {
	属性1;
	属性2;
	
	方法1;
	方法2;
}

package com.qf.a_test;

public class Person {
	/**
	 * 人类:
	 * 		属性:  Java中用变量来表示属性  int a = 20;
	 * 			姓名   年龄 性别  身高  
	 * 		行为:  Java中用方法表示行为
	 * 			吃  喝  
	 */
	//类下面的属性  不需要赋值的会给默认值的
	String name;//默认值null
	int age;//默认值0
	char sex;//char 类型是一个单一的 16 位 Unicode 字符；
	//最小值是 '\u0000'（十进制等效值为 0）；
	double height;
	
	
	//吃行为
	public void  eat ()  {
		System.out.println("吃饭饭");
	}
	
	//喝的行文
	public void drink () {
		System.out.println("喝酒酒");
	}
}

练习：

​ 狗类:

​ 属性:名字 毛色 性别

​ 行为: 打架 看家

package com.qf.a_test;

public class Dog {
	/**
	 * 名字    毛色 性别
	 */
	String name;
	String color;
	char sex;
	
	//行为 看家的方法
	public  void  lookHome () {
		System.out.println("狗汪汪叫看家");
	}
	//打架的方法
	public  void fight () {
		System.out.println("狗咬狗，一嘴毛");
	}
	
}

package com.qf.a_test;

public class Pig {
	String name;//名字
	int age;//年龄
	double weight;//体重
	
	//行为   睡觉
	public void sleep () {
		System.out.println("一般都是在睡觉");
	}
	//行为  上树
	public void upTree () {
		System.out.println("猪会上树");
	}
}

4.创建对象

一个类声明好以后，你不用它，就一直存在。但是类是用衍生出来对象的。

先有类才有对象

对象的创建在main函数中创建

创建对象的语法格式:

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

package com.qf.a_test;

//带有main主函数的叫主类
public class Demo1 {
	public static void main(String[] args) {
		//语法格式:  类名 对象的名字 = new  类名();
		Person person = new Person();
		//创建对象以后有啥用？
		//对 咱们person这个对象 进行赋值操作
		//将狗蛋 赋值给这个人（person）的(.)名字(name)  
		person.name = "狗蛋";
		person.age = 12;
		person.sex = '男';
		person.height = 168.89;
		
		//以上在赋值
		//以下在取值
		System.out.println(person.name);//获取 person对象的名字
		System.out.println(person.age);//获取 person对象的年龄
		System.out.println(person.sex);
		System.out.println(person.height);
		System.out.println("=================");
		Person person1 = new Person();
		person1.name = "张三";
		person1.age = 34;
		person1.sex = '女';
		person1.height= 189.78;
		System.out.println(person1.name);//获取 person对象的名字
		System.out.println(person1.age);//获取 person对象的年龄
		System.out.println(person1.sex);
		System.out.println(person1.height);
		
		
		//类中还有方法
		//对象.方法名字
		person.eat();
		person.drink();
		
		//属性在赋值     对象.属性 = 值;
		//方法在调用     对象.方法()
		
	}
}

练习:

​ 咱们上节课已经写过一个狗类，然后通过这个狗类创建（实例化）一个对象。对对象的属性

进行赋值，然后对象调用方法！！！

package com.qf.a_test;

import java.util.Scanner;

//Demo2 是主类
public class Demo2 {
	public static void main(String[] args) {
		//语法格式 类名 对象名字 = new  类名();
		Dog dog1 = new Dog();
		dog1.name = "旺财";
		dog1.color = "黄色";
		dog1.sex = '公';
		System.out.println("这条的名字是:"+dog1.name + "，他的性别是:" + dog1.sex+ "，他的颜色是:" + dog1.color);
		//方法的调用
		dog1.fight();
		dog1.lookHome();
	}
}

总结：

1.先新建一个类  Pig  写属性和方法
2.再新建另外一个主类  Demo2
3.在main主函数中创建对象
4.拿对象对属性进行赋值   拿对象调用方法

5.实体类和主类可以写在一个文件中

但是大家想一个问题？两个类。那么文件的名字用主类来命名

package com.qf.a_test;

//The public type Monkey must be defined in its own file
//class的前面不要再加public 了   当主类和实体类写在一起的时候
 class Monkey {
	 //属性
	String name;
	int age;
	char sex;
	
	//行为
	public void touTao () {
		System.out.println("猴子偷桃");
	}
}
public class Demo4 {
	
	public static void main(String[] args) {
		Monkey monkey = new Monkey();
		monkey.name = "孙悟空";
		monkey.age = 89;
		monkey.sex = '公';
		System.out.println("这个候叫:" + monkey.name + ":" + monkey.age + ":" + monkey.sex);
		 monkey.touTao();
	}
}

回顾上午的内容

1.声明一个类
	class Dog {//声明了狗类
		String name;
		int age;
		double weight;
		
		public void eat () {
			System.out.println("吃饭");
		}
	}
2.创建对象
	class Demo1 {//主类    main主函数的叫主类
		public  static void main (String[] args) {
			Dog dog  = new Dog();//对象的创建   又叫实例化对象
			dog.name = "牛彩云";
			dog.age = 2;
			dog.weight = 78.9;
			sout(dog.name);
			//调用狗对象的行为  吃饭
			dog.eat();
		}
	}

6.构造方法【重点】

构造方法是用来初始化对象的！！！

对象的出来和构造方法有关

无参构造方法和有参构造方法

6.1无参构造方法

语法格式：

public 类名() {
	
}

package com.qf.b_test;

//实体类 女朋友类
class GirlFriend {
	//属性
	String name;
	int age;
	//构造方法一般书写在属性的下面 方法的上面
	//在new 对象的时候 无参构造方法被调用了
	public  GirlFriend () {//无参的构造方法
		System.out.println("嘻嘻来啊");
	}
	//方法
	public void eat () {
		System.out.println("吃饭");
	}
	
}

//主类
public class Demo1 {
	public static void main(String[] args) {
		GirlFriend girlFriend = new GirlFriend();
		
	}
}

package com.qf.b_test;

//实体类 女朋友类
class GirlFriend {
	//属性
	String name;
	int age;
	//构造方法一般书写在属性的下面 方法的上面
	//在new 对象的时候 无参构造方法被调用了
	public  GirlFriend () {//无参的构造方法
		System.out.println("嘻嘻来啊");
		//this代表的是当前对象  这个
		this.name = "刘亦菲";
		this.age = 18;
		//com.qf.b_test.GirlFriend@15db9742
		System.out.println("构造方法中的：" + this);
	}
	//方法
	public void eat () {
		
		System.out.println("吃饭");
	}	
}
//主类
public class Demo1 {
	public static void main(String[] args) {
		GirlFriend girlFriend = new GirlFriend();
		//com.qf.b_test.GirlFriend@15db9742
		System.out.println("main："+girlFriend );
//		girlFriend.name = "迪丽热巴";
//		girlFriend.age = 34;
		System.out.println(girlFriend.name);
		System.out.println(girlFriend.age);
		
		
		System.out.println("=======");
		GirlFriend girlFriend1 = new GirlFriend();
		System.out.println("girg11111:"+girlFriend1);
		
		
		
		
	}
}

真实开发的时候

class BoyFriend {
	String name;
	int age;
	
	public BoyFriend () {
		
	}
}

6.2有参的构造方法

语法格式:

public 类名(参数) {

}

package com.qf.b_test;

class BoyFriend {
	String name;
	int age;
	//任何一个类都有一个默认的无参构造方法
	
	//当在一个类中声明了一个有参构造方法，默认的无参构造方法就不存了。
	public BoyFriend(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public BoyFriend () {
	}
	
	//有参构造方法，是一个参数
	public BoyFriend (int age) {
		this.age = age;
	}
	public BoyFriend (String name) {
		this.name = name;
	}
}
public class Demo2 {
	public static void main(String[] args) {
		
		BoyFriend boyFriend = new BoyFriend("狗蛋", 23);
		System.out.println(boyFriend.name);//狗蛋
		System.out.println(boyFriend.age);//19
		//在使用下面方式创建对象的时候 一定写一个无参的构造方法 才不会报错！！！
		BoyFriend boyFriend2 = new BoyFriend();
		
		//构造方法和创建对象是息息相关的
		BoyFriend boyFriend3 = new BoyFriend(13);
		BoyFriend boyFriend4 = new BoyFriend("张三");
		
	}
}

package com.qf.b_test;

class People {
	String name;
	int age;
	
	public People () {
	}
	public People (String name, int age) {
		this.name = name;
		this.age = age;
	}
}
public class Demo3 {
	public static void main(String[] args) {
		People people = new People();
		System.out.println(people.name);//null
		System.out.println(people.age);//0
		People people1 = new People("goudan", 29);
		System.out.println(people1.name);//goudan
		System.out.println(people1.age);//29
		
	}
}

练习:

猫类：

​ 属性： 名字 年龄 性别

​ 构造方法: 无参构造方法和有参构造

​ 行为: 抓老鼠

package com.qf.b_test;

class Cat {
	String name;//名字
	int age;//年龄
	char sex;//性别
	
	public Cat () {
		
	}
	public Cat (String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	//抓老鼠
	public void catchMouse () {
		System.out.println("猫抓老鼠可牛了");
	}
}
public class Demo4 {
	public static void main(String[] args) {
		Cat cat = new Cat();//因为上面类中有一个无参的构造方法，所以才没有报错
		//对属性进行赋值
		cat.name = "大黄";
		cat.age = 12;
		System.out.println(cat.name);
		System.out.println(cat.age);
		cat.catchMouse();
		
		System.out.println("============");
		Cat cat1 = new Cat("加菲", 4);
		System.out.println(cat1.name);
		System.out.println(cat1.age);
		cat1.catchMouse();
		
		
	}
}

7.对象的内存分析

8.构造代码块【了解】

现在开发已经不用了

构造i代码块：也是对对象进行初始化的，功能和构造方法是一样的。

语法格式:

{
	语句体
}

package com.qf.b_test;

class Tiger {
	String name;
	int age;

	// 构造代码块
	{
		System.out.println("Tiger的构造i代码块");
		this.name = "狗蛋";
		this.age = 23;
	}

	// 无参构造方法
	public Tiger() {
		System.out.println("Tiger的无参构造方法执行了");
		this.name = "战三";
		this.age = 12;
	}

}

public class Demo5 {
	public static void main(String[] args) {
		Tiger tiger = new Tiger();
		tiger.name = "lisi";
		tiger.age = 14;
		System.out.println(tiger.name);
		System.out.println(tiger.age);
	}
}

作业：

1.十二生肖 写在同一个文件中和主类
 属性自己想
 方法也自己想
 无参和有参构造方法（对属性进行赋值）
 在main主函数中创建对象
2.

ckage com.qf.b_test;

class Tiger {
String name;
int age;

// 构造代码块
{
	System.out.println("Tiger的构造i代码块");
	this.name = "狗蛋";
	this.age = 23;
}

// 无参构造方法
public Tiger() {
	System.out.println("Tiger的无参构造方法执行了");
	this.name = "战三";
	this.age = 12;
}

}

public class Demo5 {
public static void main(String[] args) {
Tiger tiger = new Tiger();
tiger.name = “lisi”;
tiger.age = 14;
System.out.println(tiger.name);
System.out.println(tiger.age);
}
}

练习：

1.十二生肖 写在同一个文件中和主类
属性自己想
方法也自己想
无参和有参构造方法（对属性进行赋值）
在main主函数中创建对象
2.