JAVA语言基础-面向对象(构造方法)

时间 2019-12-04

原文原文链接

1.构造方法Constructor概述及做用java

1.1做用设计模式

给对象的数据(属性)进行初始化数组

class Demo1_Constructor {						//Constructor构造
	public static void main(String[] args) {
		Person p = new Person();				//在一建立对象的时候,系统就帮我调用了构造方法
		//p.Person();							//构造方法不能用对象调用
		p.show();

		Person p2 = new Person();				//再次建立对象
	
		p2.show();
	}
}

/*
* A:构造方法概述和做用
	* 给对象的数据(属性)进行初始化
* B:构造方法格式特色
	* a:方法名与类名相同(大小也要与类名一致)
	* b:没有返回值类型，连void都没有
	* c:没有具体的返回值return;
*/

class Person {
	private String name;
	private int age;

	//构造方法
	public Person() {
		//System.out.println("Hello World!");
		//return;								//构造方法也是有return语句的,格式是return;
		name = "张三";
		age = 23;
	}

	public void show() {
		System.out.println(name + "..." + age);
	}
}

1.2格式特色dom

方法名与类名相同(大小也要与类名一致)jvm

没有返回值类型，连void都没有函数

没有具体的返回值return;工具

2.构造方法的重载及注意事项学习

class Demo2_Person {
	public static void main(String[] args) {

		//对象名.方法名();
		//构造方法 不能单独调用 ,只能在建立对象的时候调用
		//我怎么区分我调用的是有参的构造方法,仍是无参的构造方法?
		//你传了对应的参数,就调用了对应的构造方法,若是你不传任何参数,那会无参的构造方法!!
		//Person();

		Person p1 = new Person();
		p1.show();

		System.out.println("---------------------");

		Person p2 = new Person("张三",23);
		p2.show();

		System.out.println("---------------------");

		Person p3 = new Person("李四",24);
		p3.show();
	}
}
/*
* A:案例演示
	* 构造方法的重载
	* 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
* B:构造方法注意事项
	* a:若是咱们没有给出构造方法，系统将自动提供一个无参构造方法。
	* b:若是咱们给出了构造方法，系统将再也不提供默认的无参构造方法。
		* 注意：这个时候，若是咱们还想使用无参构造方法，就必须本身给出。建议永远本身给出无参构造方法
		
*/
class Person {
	private String name;			//姓名
	private int age;				//年龄

	public Person() {				//空参构造
		System.out.println("空参的构造");
	}

	public Person(String name,int age) {
		this.name = name;
		this.age = age;
		System.out.println("有参的构造");
	}
	
	public void show() {
		System.out.println(name + "..." + age);
	}
}

2.1构造方法的重载this

方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表.net

2.2注意事项

若是咱们没有给出构造方法，系统将自动提供一个无参构造方法。

若是咱们给出了构造方法，系统将再也不提供默认的无参构造方法。

注意：这个时候，若是咱们还想使用无参构造方法，就必须本身给出。建议永远本身给出无参构造方法

3.给成员变量赋值的两种方式的区别

class Demo3_Person {
	public static void main(String[] args) {
		Person p1 = new Person("张三",23);
		//p1 = new Person("张天一",23);	//这种方式看运行结果貌似是更名了,实际上是将原对象变成垃圾
		System.out.println(p1.getName() + "..." + p1.getAge());

		System.out.println("--------------------");
		Person p2 = new Person();		//空参构造建立对象
		p2.setName("李四");
		p2.setAge(24);

		p2.setName("李鬼");
		System.out.println(p2.getName() + "..." + p2.getAge());
	}
}
/*
构造方法
	给属性进行初始化
setXxx方法
	修改属性值
	这两种方式,在开发中用setXxx更多一些,由于比较灵活
*/
class Person {
	private String name;				//姓名
	private int age;					//年龄

	public Person() {					//空参构造
	}

	public Person(String name,int age) {//有参构造
		this.name = name;
		this.age = age;
	}
	
	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;
	}
}

3.1setXxx()方法

修改属性值

开发中用setXxx更多一些,由于比较灵活

class Demo4_Student {
	public static void main(String[] args) {
		Student s1 = new Student();					//使用空参构造
		s1.setName("张三");							//设置姓名
		s1.setAge(23);								//设置年龄

		System.out.println("个人姓名是:" + s1.getName() + ",个人年龄是:" + s1.getAge());
		//getXxx()获取属性值,能够打印,也能够赋值给其余的变量,作其余的操做
		Student s2 = new Student("李四",24);
		s2.show();									//只是为了显示属性值
	}
}
/*
* A:案例演示
	* 学生类：
		* 成员变量：
			* name，age
		* 构造方法：
			* 无参，带两个参
		* 成员方法：
			* getXxx()/setXxx()
			* show()：输出该类的全部成员变量值
* B:给成员变量赋值：
	* a:setXxx()方法
	* b:构造方法
	
* C:输出成员变量值的方式：
	* a:经过getXxx()分别获取而后拼接
	* b:经过调用show()方法搞定
*/

class Student {
	private String name;							//姓名
	private int age;								//年龄

	public Student(){}								//空参构造

	public Student(String name,int age) {			//有参构造
		//赋值
		this.name = name;
		this.age = age;
	}

	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;
	}

	public void show() {
		System.out.println("个人姓名是:" + name +  ",个人年龄是:" +  age);
	}
}

3.2构造方法

给对象中属性进行初始化

4.一个对象的建立过程作了哪些事情?

Student s = new Student();
Student.class加载进内存
声明一个Student类型引用s
在堆内存建立对象,
给对象中属性默认初始化值
属性进行显示初始化
构造方法进栈,对对象中的属性赋值,构造方法弹栈
将对象的地址值赋值给s

5.static关键字

5.1带有static的内存图

5.2 static关键字的特色

a:随着类的加载而加载
b:优先于对象存在
c:被类的全部对象共享
- 举例：班级的学生应该共用同一个班级编号。
- 其实这个特色也是在告诉咱们何时使用静态?
  - 若是某个成员变量是被全部对象共享的，那么它就应该定义为静态的。
- 举例：
  - 饮水机(用静态修饰)
  - 水杯(不能用静态修饰)
  - 共性用静态,特性用非静态
d:能够经过类名调用
- 其实它自己也能够经过对象名调用。
- 推荐使用类名调用。
- 静态修饰的内容通常咱们称其为：与类相关的，类成员

class Demo1_Static {
	public static void main(String[] args) {
		Person p3 = new Person();
		p3.name = "福原爱老师";		//调用姓名属性并赋值
	    p3.country = "台湾";		//调用国籍属性并赋值
		p3.speak();

		Person p1 = new Person();	//建立对象
		p1.name = "苍老师";			//调用姓名属性并赋值
		p1.country = "日本";		//调用国籍属性并赋值
		p1.speak();

		Person p2 = new Person();
		p2.name = "小泽老师";		//调用姓名属性并赋值
	   // p2.country = "日本";		//调用国籍属性并赋值
		p2.speak();

		Person p4 = new Person();
		p4.name = "黄老师";		//调用姓名属性并赋值
	   // p2.country = "日本";		//调用国籍属性并赋值
		p4.speak();
		

		
		
	

		//Person.country = "日本";	//静态多了一种调用方式,能够经过类名.
		//System.out.println(Person.country);
	}
}

class Person {
	String name;					//姓名
	static String country;					//国籍

	public void speak() {			//说话的方法
		System.out.println(name + "..." + country);
	}
}

5.3 static的注意事项

a:在静态方法中是没有this关键字的
- 如何理解呢?
  - 静态是随着类的加载而加载，this是随着对象的建立而存在。
  - 静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
- 静态方法：
  - 成员变量：只能访问静态变量
  - 成员方法：只能访问静态成员方法
- 非静态方法：
  - 成员变量：能够是静态的，也能够是非静态的
  - 成员方法：但是是静态的成员方法，也能够是非静态的成员方法。
- 简单记：
  - 静态只能访问静态

class Demo2_Static {
	public static void main(String[] args) {
		//Demo d = new Demo();
		//d.print1();
		//Demo d = new Demo();
		//System.out.println(d.num1);
		System.out.println(Demo.num1);
		//Demo.print2();
	}
}

/*
* A:static的注意事项
	* a:在静态方法中是没有this关键字的
		* 如何理解呢?
			* 静态是随着类的加载而加载，this是随着对象的建立而存在。
			* 静态比对象先存在。
	* b:静态方法只能访问静态的成员变量和静态的成员方法
		* 静态方法：
			* 成员变量：只能访问静态变量
			* 成员方法：只能访问静态成员方法
		* 非静态方法：
			* 成员变量：能够是静态的，也能够是非静态的
			* 成员方法：但是是静态的成员方法，也能够是非静态的成员方法。
		* 简单记：
			* 静态只能访问静态。
*/

class Demo {
	int num1 = 10;						//非静态的成员变量
	static int num2 = 20;				//静态的成员变量

	/*public void print1() {				//非静态的成员方法,既能够访问静态的成员也能够访问非静态的
		System.out.println(num1);
		System.out.println(num2);
	}*/

	public static void print2() {		//静态的成员方法
		//System.out.println(this.num1);//静态的成员方法不能访问非静态的,错误: 没法从静态上下文中引用非静态 变量 num1
		System.out.println(num2);
	}
}

5.4 静态变量和成员变量的区别

静态变量也叫类变量成员变量也叫对象变量
A:所属不一样
- 静态变量属于类，因此也称为为类变量
- 成员变量属于对象，因此也称为实例变量(对象变量)
B:内存中位置不一样
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
C:内存出现时间不一样
- 静态变量随着类的加载而加载，随着类的消失而消失
- 成员变量随着对象的建立而存在，随着对象的消失而消失
D:调用不一样
- 静态变量能够经过类名调用，也能够经过对象调用
- 成员变量只能经过对象名调用 ###07.13_面向对象(main方法的格式详细解释)(了解)

A:格式
- public static void main(String[] args) {}
B:针对格式的解释
- public 被jvm调用，访问权限足够大。
- static 被jvm调用，不用建立对象，直接类名访问
- void被jvm调用，不须要给jvm返回值
- main 一个通用的名称，虽然不是关键字，可是被jvm识别
- String[] args 之前用于接收键盘录入的
C:演示案例
- 经过args接收键盘例如数据

###07.14_面向对象(工具类中使用静态)(了解)

A:制做一个工具类
- ArrayTool
- 1,获取最大值
- 2,数组的遍历
- 3,数组的反转

/**
这是一个数组工具类,里面封装了查找数组最大值,打印数组,数组反转的方法
@author fengjia
@version v1.0
*/
public class ArrayTool {
	//若是一个类中全部的方法都是静态的,须要再多作一步,私有构造方法,目的是不让其余类建立本类对象
	//直接用类名.调用便可
	/**
	私有构造方法
	*/
	private ArrayTool(){} //设计模式:单例模式

	//1,获取最大值

	/**
	这是获取数组中最大值的方法
	@param arr 接收一个int类型数组
	@return 返回数组中最大值
	*/
	public static int getMax(int[] arr) {
		int max = arr[0];						//记录第一个元素
		for (int i = 1;i < arr.length ;i++ ) {	//从第二个元素开始遍历
			if (max < arr[i]) {					//max与数组中其余的元素比较
				max = arr[i];					//记录住较大的
			}
		}

		return max;								//将最大值返回
	}
	//2,数组的遍历
	/**
	这是遍历数组的方法
	@param arr 接收一个int类型数组
	*/
	public static void print(int[] arr) {
		for (int i = 0;i < arr.length ;i++ ) {	//遍历数组
			System.out.print(arr[i] + " ");
		}
	}
	//3,数组的反转
	/**
	这是数组反转的方法
	@param arr 接收一个int类型数组
	*/
	public static void revArray(int[] arr) {
		for (int i = 0;i < arr.length / 2 ;i++ ) {	//循环次数是元素个数的一半
			/*
			arr[0]与arr[arr.length-1-0]	交换
			arr[1]与arr[arr.length-1-1]	交换
			arr[2]与arr[arr.length-1-2] 交换
			*/
			int temp = arr[i];
			arr[i] = arr[arr.length-1-i];
			arr[arr.length-1-i] = temp;
		}
	}
}

###07.15_面向对象(说明书的制做过程)(了解)

A:对工具类加入文档注释
B:经过javadoc命令生成说明书
- @author(提取做者内容)
- @version(提取版本内容)
- javadoc -d 指定的文件目录 -author -version ArrayTool.java
- @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据

###07.16_面向对象(如何使用JDK提供的帮助文档)(了解)

A:找到文档，打开文档
B:点击显示，找到索引，出现输入框
C:你应该知道你找谁?举例：Scanner
D:看这个类的结构(需不须要导包)
- 成员变量字段
- 构造方法构造方法
- 成员方法方法

###07.17_面向对象(学习Math类的随机数功能)(了解)

打开JDK提供的帮助文档学习
A:Math类概述
- 类包含用于执行基本数学运算的方法
B:Math类特色
- 因为Math类在java.lang包下，因此不须要导包。
- 由于它的成员所有是静态的,因此私有了构造方法
C:获取随机数的方法
- public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
- int number = (int)(Math.random()*100)+1;

class Demo2_Math {
	public static void main(String[] args) {
		//double d = Math.random();
		//System.out.println(d);
		
		//Math.random()会生成大于等于0.0而且小于1.0的伪随机数
		for (int i = 0;i < 10 ;i++ ) {
			System.out.println(Math.random());
		}

		//生成1-100的随机数
		//Math.random()0.0000000 - 0.999999999
		//Math.random() * 100 ====> 0.00000 - 99.999999999
		//(int)(Math.random() * 100) ====> 0 - 99
		//(int)(Math.random() * 100) + 1

		for (int i = 0;i < 10 ;i++ ) {
			System.out.println((int)(Math.random() * 100) + 1);
		}
	}
}

###07.18_面向对象(猜数字小游戏案例)(了解)

A:案例演示
- 需求：猜数字小游戏(数据在1-100之间)