Java学习第七天2021.7.27

今天学习了在自定义数据类型中写入方法并进行调用

成员方法

在昨天的学习中，学习到了自定义的数据类型，在Java中数据类型分为两种，一种是引用数据类型，一种是基本数据类型。引用的数据类型需要进行new，然后在栈区存放的是地址，在堆区中存的才是真正的数据。
基本数据类型有八种：int、short、long、byte、double、float、char、boolean。其余的数据类型均为引用类型。
咱们去看Java的源码，看Scanner的源码，下面这一行就是定义了成员变量

而下面的代码就是成员方法

发现其定义的格式也是：修饰符 返回值类型 方法名（）{}。只不过没有使用static，咱们先不使用static。

成员方法的使用和定义

模仿Java的源码来写一下成员方法，定义一个Student类，在里面定义一个print方法来输出hello world。
分析：
1.创建项目并进行测试
2.创建Student类（位置：并列 格式：class 名字{}）
3.在类中创创建一个成员方法（格式：修饰符 返回值类型 方法名（））
4.在方法中输出hello world
5.在主方法中定义一个Student的变量s
6.调用s的方法pritn（）

下面就是完整的代码

class demo01
{
	public static void main(String[] args){
		Student s = new Student();
		s.print();
	}
}
class Student
{
	public void print(){
		System.out.println("hello world");
	}
}

咱们就了解的成员方法的使用和定义

小练习

需求：定义一个dog类，这个里面有体重和姓名，有三个方法，吃饭方法，使体重+10。跑步方法，使体重-10。输出方法，输出姓名和体重
分析：
1.创建项目并进行测试
2.写dog类，并且在类中先定义出成员变量
位置：并列 格式：class 名字{}
变量格式：数据类型 变量名 = 数值；
3.在类中写出来所需要的print方法
方法格式：修饰符 返回值类型 方法名（）{}
4.在main方法中定义出来一个dog类型的变量d
5.运用d的方法

代码如下：

class demo01
{
	public static void main(String[] args){
		dog d = new dog();
		d.wight = 100;
		d.name = "aaaa";
		//先输出一次
		d.print();
		System.out.println("----------");
		//跑之后再输出一次
		d.run();
		d.print();
		System.out.println("----------");
		//吃完饭在输出
		d.chifan();
		d.print();
	}
}
class dog
{
	int wight;
	String name;
	public void run(){
		wight = wight - 10;
	}
	public void chifan(){
		wight = wight + 10;
	}
	public void print(){
		System.out.println("体重:"+wight+",姓名:"+name);
	}
}

成员变量和成员方法与变量和方法的区别

成员变量和变量的区别

1.位置上：

• 成员变量位于类之中，方法之外
• 变量位于方法之中

2.初始化赋值

• 成员变量不需要进行初始化赋值，int类型的初始值是0，String是null
• 变量的使用需要进行初始化赋值

3.同名的时候

• 如果有成员变量和变量同名，系统不在提供this关键字
• 如果只有成员变量的时候，系统会提供this关键字

成员方法和方法的区别

成员变量没有static
方法有static

有static的东西在类被加载的时候自动被加载，而没有static的则不会进行加载，只有在new一个实例的时候才会把没有加static的东西进行加载
下面将举例子

class demo01
{
	public static void main(String[] args){
		A.m();
	}
}
class A
{
	public static void m(){
		System.out.println("hello world");
	}
}

这样是可以正常使用的，但是在非静态的东西中，不对其进行实例化是不能用的

class demo01
{
	public static void main(String[] args){
		A.m();
	}
}
class A
{
	public void m(){
		System.out.println("hello world");
	}
}

会发现报错了，咱们再进行实例化一下试试

class demo01
{
	public static void main(String[] args){
		A a = new A();
		a.m();
	}
}
class A
{
	public void m(){
		System.out.println("hello world");
	}
}

这样就可以正常输出了。
咱们试了方法，再试一下变量可以不可以用static

class demo01
{
	public static void main(String[] args){
		A.m();
	}
}
class A
{
	int a = 10;
	public static void m(){
		System.out.println(a);
	}
}

会发现和上面的错误一样，m方法无法访问a变量，咱们把变量改成static试试

class demo01
{
	public static void main(String[] args){
		A.m();
	}
}
class A
{
	static int a = 10;
	public static void m(){
		System.out.println(a);
	}
}

会发现会输出10这个数字，咱们把方法改成非静态的，变量不变再试试

class demo01
{
	public static void main(String[] args){
		A a = new A();
		a.m();
	}
}
class A
{
	static int a = 10;
	public void m(){
		System.out.println(a);
	}
}

发现可以。这样咱们就可以做出一个关于静态和非静态的一个结论：静态的东西只能调用静态的东西（这个东西包括方法和变量），但是非静态的可以随意进行调用，即可以调用静态的，也可以调用非静态的

数据加载的时机

有static修饰的时候，数据加载在类被加载的同时进行加载
没有static修饰的时候，是在实例被创建出来的时候进行的创建

构造方法

构造方法概述

构造方法是一个类所必须的东西，构造方法其实在咱们写代码的时候会自动加上。这个构造方法的格式是：public 类名(){}
其实咱们在new实例的时候就是调用的构造方法，然后如果咱们自己写上了构造方法，那系统就不会自己加上去构造方法
下面就是自己写出来构造方法

class demo02{
	demo02(){
	}
}

咱们可以自己定义构造方法，下面就举了一个例子

class demo02
{
	public static void main(String[] args){
		new B();
	}
}
class B
{
	public B(){
		System.out.println("hello wrold");
	}
}

再举个例子

class demo02
{
	public static void main(String[] args){
		new B(10);
	}
}
class B
{
	public B(int a){
		System.out.println(a);
	}
}

当然也可以定义一个值来接收new出来的实例对象，但是咱们输出了，就不用定义了。

但是在咱们自定义构造方法的时候，还要加上无参的构造方法，这样咱们在不输入参数的时候也能使用构造方法

class demo02
{
	public static void main(String[] args){
		B b = new B(10);
	}
}
class B
{
	public B(){
	}
	public B(int a){
		System.out.println(a);
	}
}

构造方法细节

• 成员变量和有参构造的变量同名
• 构造方法只能够赋值，不能改值（在创建对象的同时，完成赋值
• 普通的方式：可以赋值，也可以修改值（在创建完实体后，完成的赋值)
• 没有空参构造方法也可以，但是建议加上，因为在创建实体的时候，会更加的灵活