Java-Day11 面向对象遍程的入门 (类属性的默认值、构造方法、类的成员、static关键字、类的成员加载顺序、Java(权限)访问修饰符)

Golang_HZ

已于 2022-08-03 22:47:56 修改

阅读量565

点赞数

分类专栏： Java 文章标签： java jvm servlet

于 2022-07-22 10:26:45 首次发布

本文链接：https://blog.csdn.net/weixin_51612062/article/details/125905795

版权

Java 专栏收录该内容

21 篇文章 2 订阅

订阅专栏

1. 类的属性的默认值问题

在Java中，如果定义类的使用，存在属性，没有给属性赋值，Java则会有默认值。

8种基本数据类型的默认值：

整形：0
浮点型：0.0
boolean：false
char：' ' 空
对象(String、数组等)：null

重写toString()方法：

该方法在打印对象的时候，会自动输出对象的属性，而不是输出对象的hashcode值，因为默认类继承的是Object类的toString方法

public class PersonTest1 {
	public static void main(String[] args) {
		Person p1 = new Person();
		System.out.println(p1);
		// Person [id=0, name=null, age=0, gender=false, height=0.0, weight=0.0, aa=0, bb=0, cc=
	}
}

class Person {
	// 定义属性
	public long id;
	public String name;
	public int age;
	public boolean gender;
	public float height;
	public double weight;
	public byte aa;
	public short bb;
	public char cc;
	
	// 鼠标放到最后一个属性后，右键找到source --> Generate toString()
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", height=" + height
				+ ", weight=" + weight + ", aa=" + aa + ", bb=" + bb + ", cc=" + cc + "]";
	}

	public void eat() {
		System.out.println("到点该吃饭啦！");
	}
	
	public void run() {
		System.out.println("跑起来，太慢了！");
	}
}

2. 构造方法(Constructor)

构造器的特征：

它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值

在Java类中，如果没有自己定义构造函数，系统(JVM)自动会生成一个无参的构造，方便我们构建一个属性都为默认值的对象。但是当我们定义了一个构造函数之后，系统(JVM)将不再自动生成一个无参的构造，如果需要这个无参，需要自己定义。

注意：

Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承

构造函数()的作用：

创建对象；给对象初始化属性！！！在创建对象时不必再依次赋值

this关键字指针的使用：

在Java中，存在this关键字，这个关键字默认会指向当前对象

public class CatTest {
	public String name;
	public int age;
	public boolean gender;

	@Override
	public String toString() {
		return "CatTest [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}

	// 构造方法Constructor：初始化属性！！！
	// 不需要声明返回值类型
	// 多参构造
	public CatTest(String _name, int _age, boolean _gender) {
//		name = _name;
//		age = _age;
//		gender = _gender;
		
		// this关键字默认会指向当前对象
		this.name = _name;
		this.age = _age;
		this.gender = _gender;
	}
	
	// 单参构造
	public CatTest(String _name) {
		name = _name;
	}
	
	// 在定义构造函数时，一定要定义一个无参构造
	public CatTest() {
		
	}
	
	public static void main(String[] args) {
		CatTest cat1 = new CatTest();
		cat1.name = "小黄";
		cat1.age = 10;
		cat1.gender = true;
		System.out.println(cat1);
		
		CatTest cat2 = new CatTest("小汪", 8, true);
		System.out.println(cat2);
		
		CatTest cat3 = new CatTest("小花");
		cat3.age = 5;
		cat3.gender = false;
		System.out.println(cat3);
	}
}

3. 类的成员

属性(成员变量)
方法(对象方法或实例方法)
构造方法(构造器)
静态属性(类属性)
静态方法(类方法)
构造代码块
静态代码块
内部类

3.1 类的成员之一：属性

属性是类的成员之一，又叫成员变量。

成员变量中又包括实例属性(不以static修饰)、类属性(static修饰的，也叫静态属性))

语法格式：

修饰符 数据类型 属性名 = 初始化值 ;

修饰属性的修饰符：

常用的修饰属性的权限修饰符有：private、缺省、protected、public

其他修饰符：static(类属性)、final (常量)

成员变量和局部变量

在方法体外，类体内声明的变量称为成员变量。在方法体内部声明的变量称为局部变量。

注意：二者在初始化值方面的异同：

同：都有生命周期
异：局部变量除形参外，均需显式初始化。

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部、代码块内、构造器内等
修饰符	private、public、static、final等	不能用权限修饰符修饰，可以用final修饰
初始化值	有默认初始化值	没有默认初始化值，必须显式赋值，方可使用
内存加载顺序	堆空间或静态域内	栈空间

3.2 UML类图

1. + 表示 public 类型， - 表示 private 类型，#表示protected类型

2. 方法的写法: 方法的类型(+、-) 方法名(参数名：参数类型)：返回值类型

4. static关键字

static关键字可以修饰非常多的东西 (如：属性、方法、类、语法块、导包)

static可以修饰属性
static可以修饰方法
ststic可以修饰类，注意，只能修饰内部类
static可以修饰包，静态导包
static静态代码块，提前加载到内存中，只加载一次

static修饰的代码，会提取加载到内存中，并且只有一份，属于该类，因此：静态方法中，无法直接调用非静态函数 (属性)

被static修饰的属性和方法，不属于对象，属于该类，是类的成员，直接使用类名称.属性/类名称.方法 (广泛的被使用在工具类中)，而不是使用对象名.属性/对象名.方法

构造方法如果是private关键字修饰的，无法通过new的方法创建对象。

static { // 构造代码块} // 静态代码块

public class TestStatic {
	
	public int age;
	// 静态属性
	public static int aa;
	
	public void say() {
		System.out.println("hello static ");
	}
	
	public static void sayHello() {
		System.out.println("这个是一个静态方法");
	}
	
	{
		// 构造代码块
	}
	
	static {
		// 静态代码块
	}
	
	public static void main(String[] args) {
//		System.out.println(age);
//		System.out.println(aa);
//		say();
//		sayHello();
		
		MyUtil myUtil = new MyUtil();
//		System.out.println(myUtil.PI);
//		System.out.println(myUtil.age);
		System.out.println(myUtil.name);
		
//		myUtil.age = 30;
//		System.out.println(myUtil.age);
		
		// 静态属性，直接使用类名称调用
		System.out.println(MyUtil.PI);
		System.out.println(MyUtil.age);
		
		MyUtil myUtil02 = new MyUtil();
//		System.out.println(myUtil02.age);

	}
	
	// static还可以修饰类，注意，只能修饰内部类
	static class Test {
		
	}
}

class MyUtil {
	
	public final static double PI = 3.14;
	public static int age = 20;
	public String name = "小明";
	
	public void say() {
		System.out.println("hello static ");
	}
	
	public static void sayHello() {
		System.out.println("这个是一个静态方法");
	}
	
	
}

5. 类的成员加载(运行)顺序

属性最先运行，之后是构造函数。

static修饰的属性和静态代码块最先运行（这两者之间看代码顺序），之后才开始运行对象属性和构造代码块（这两者之间看代码顺序），最后构造函数开始运行。

static修饰的属性 ==> 静态代码块 ==> 构造代码块(属性前) ==> 对象属性 ==> 构造代码块(属性后) ==> 构造方法

public class StaticTest {
	{
//		System.out.println(name1); // 无法解析变量name1
		System.out.println(name2); // da
		System.out.println("1");
	}
	
	public StaticTest() {
		System.out.println("2");
	}
	
	public String name = "xiao";
	public static String name2 = "da";
	public int age = 12;
	public static int age2 = 30;

	{
		System.out.println(age); // 12
		System.out.println(age2); // 30
		System.out.println("3");
	}
	
	static {
		// 只会执行一次
		System.out.println("4");
//		System.out.println(name); // 无法对非静态字段名进行静态引用
		System.out.println(name2); // 静态属性在静态代码块之前
	}

	public StaticTest(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "StaticTest [name=" + name + ", age=" + age + "]";
	}

	public static void main(String[] args) {
		StaticTest s1 = new StaticTest();
		System.out.println();
		StaticTest s2 = new StaticTest();
	}
}

6. Java(权限)访问修饰符：

public：任何地方都可以正常访问该修饰符的属性和方法
protected：同包、同类、允许子类访问
缺省(默认)：同包、同类
private：只能是当前类访问，不允许超过该类

注意：class类，只能被public和默认这两种访问修饰符修饰

public class Person02 {
	public String name = "小明";
	protected int age = 18;
	String gender = "男";
	private String nickname = "Ming";
	
	public void say() {
		System.out.println(this.nickname);
		this.say("小明");
	}
	
	private void say(String name) {
		System.out.println(this.nickname +"-->"+ name);
	}
	
	protected void money() {
		System.out.println("孙子，叫声爷爷，给你钱");
	}
}

public class ModifierTest {
	public static void main(String[] args) {
		
		Person02 midifier = new Person02();
		System.out.println(midifier.age);
		System.out.println(midifier.gender);
		System.out.println(midifier.name);
//		System.out.println(midifier.nickname);  // 私有private了
//		midifier.say("道可道");  //private的方法
		
		midifier.money();
	}
}

7. this关键字

7.1 this关键字是干什么的？

在Java中，this关键字比较难理解，它的作用和其词义很接近。

1. 它在方法内部使用，即这个方法所属对象的引用；

2. 它在构造器内部使用，表示该构造器正在初始化的对象。

this 可以调用类的属性、方法和构造器，不可以调用静态属性和方法，即不能调用类属性和类方法。

原因：this是在堆内存中的类中，而类方法(静态方法)在方法区的静态域中，所以无法通过this进行访问

7.2 什么时候使用this关键字呢？

当在方法内需要用到调用该方法的对象时，就用this。

具体的：我们可以用this来区分属性和局部变量。比如：this.name = name

1. 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。

2. 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量

3.使用this访问属性和方法时，如果在本类中未找到，会从父类中查找

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
        this.name = name ; 
        this.age = age ;
    }

    public void getInfo(){
        System.out.println("姓名：" + name) ;
        this.speak();
    }
    
    public void speak(){
        System.out.println(“年龄：” + this.age);
    }
}

4.this可以作为一个类中构造器相互调用的特殊格式：

可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
不能通过这种方式调用自身的构造，
"this(形参列表)"必须声明在类的构造器的首行！
如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"，
在类的一个构造器中，最多只能声明一个"this(形参列表)"

class Person{ // 定义Person类
    private String name ;
    private int age ;

    public Person(){ // 无参构造器
        System.out.println("新对象实例化") ;
    }

    public Person(String name){
        this(); // 调用本类中的无参构造器
        this.name = name ;
    }

    public Person(String name,int age){
        this(name) ; // 调用有一个参数的构造器
        this.age = age;
    }

    public String getInfo(){
        return "姓名：" + name + "，年龄：" + age ;
    } 
}