Java基础第九课（类和对象的讲解）

最新推荐文章于 2023-06-15 17:30:06 发布

周秃秃

最新推荐文章于 2023-06-15 17:30:06 发布

阅读量218

点赞数

分类专栏： Java基础 Java基础文章标签：类和对象枚举增强型for循环遍历 this 方法重载

本文链接：https://blog.csdn.net/qq_43191313/article/details/89298498

版权

Java基础同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

Java基础

23 篇文章 0 订阅

订阅专栏

今天的知识点有点儿多
大家耐心点儿哦
开始

一、引用

这个之前就接触过了
我这里就直接代码演示吧

package com.baidu.demo.test5;

public class Demo1 {

	String name;
	int age;
	
	public static void main(String[] args) {
		//创建一个对象
		new Demo1();

		//使用一个引用来指向这个对象
		Demo1 demo1 = new Demo1();
		
	}

}

二、继承

所谓的继承，就是在新建的一个类中
如果继承了上一个类
那么我们就可以直接用上一个类中的方法或者属性…
代码演示：
首先我们先创建一个Item类

package com.baidu.demo.test5;

public class Item {
	//声明两个属性
	String name = "张三";
	int age = 22;
	
	//声明一个静态方法，该方法可以直接被调用
	public static void printText() {
		System.out.println("测试");
	}
}

然后我们再创建一个Demo2进行测试

package com.baidu.demo.test5;

//extends是继承的意思，这里我们继承Item类
public class Demo2 extends Item {
	public static void main(String[] args) {
		
		//我们实例化一个Demo2类
		Demo2 demo2 = new Demo2();
		
		//这里我们并没有声明name属性，但是我们继承的Item类中有name属性，所以我们这里可以直接访问
		System.out.println(demo2.name);
		
		//我们再使用我们继承的Item类中的printText方法，这个方法也是Item类中的
		demo2.printText();
	}
}

运行Demo2结果：
在这里插入图片描述

三、方法重载

方法的重载指的是方法名一样，但是参数类型不一样
好了，直接上代码

package com.baidu.demo.test5;

public class Demo3 {
	
	//这里我们声明三个名字一样的方法，但是里面的数据类型或者个数不一样
	public static void a() {
		System.out.println("方法一");
	}
	
	public static void a(String text) {
		System.out.println("方法二" + text);
	}
	
	public static void a(String text,int number) {
		System.out.println("方法三" + text + "\t" + number);
	}
	
	public static void main(String[] args) {
		
		//调用上面的三个方法，虽然名字一样，但是里面的参数不一样，所以想调用哪个方法直接带上相应类型的参数就行了
		//因为方法是静态方法，所以直接调用就行了
		a();
		a("张三");
		a("李四",22);
		
	}
}

运行结果：
在这里插入图片描述

四、构造方法

通过一个类创建一个对象，这个过程叫做实例化
但是实例化是通过调用构造方法(又叫做构造器)实现的
也就是说，实例化一个对象的时候，必然调用构造方法
下面还是用代码来演示吧

package com.baidu.demo.test5;

public class Demo4 {
	
	//其实我们在实例化一个类的时候，默认的调用的就是和类名同名的一个方法，这个方法里面默认是什么都没有的，这里我们来修改一下，给它在实例化的时候就打印出来一句话
	public Demo4() {
		System.out.println("Demo4被实例化");
	}
	
	public static void main(String[] args) {
		
		//实例化该类
		Demo4 demo4 = new Demo4();
		
	}
}

运行结果：
在这里插入图片描述

下面讲解下有参构造方法，以及它的重载
代码如下

package com.baidu.demo.test5;

public class Demo5 {
	
	//因为下面有有参构造，所以如果不添加上默认的这个构造方法，在实例化没有参数的时候将会报错
	public Demo5() {
		
	}
	
	//声明一个有参构造方法
	public Demo5(String name) {
		System.out.println("有参构造一:"+name);
	}
	
	//重载一个有参构造方法
	public Demo5(String name,int age) {
		System.out.println("有参构造二:"+name+age);
	}
	
	public static void main(String[] args) {
		
		//匿名实例化该类
		new Demo5();
		
		//匿名实例化有参一
		new Demo5("张三");
		
		//匿名实例化有参二
		new Demo5("张三",22);
		
	}
}

运行结果：
在这里插入图片描述

五、this关键字

this这个关键字，相当于普通话里的“我”
this即代表当前对象的讲解
代码演示：

package com.baidu.demo.test5;

public class Demo6 {
	
	String name;
	
	public void setName(String name) {
		//这里的this.name指的就是当前类的name属性，也就是说给上面声明的name属性赋值
		this.name = name;
	}
	
	public static void main(String[] args) {
		
		//因为setName方法不是静态方法，所以不能直接被调用，得先实例化Demo6类，通过实例化得Demo6进行调用
		Demo6 demo6 = new Demo6();
		demo6.setName("张三");
		
		//打印上面的name属性
		System.out.println(demo6.name);
		
	}
}

运行结果：
在这里插入图片描述

六、单例模式

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。
饿汉式单例模式
通过私有化其构造方法，使得外部无法通过new 得到新的实例。
然后我们提供一个方法，外部调用者通过该方法获对象，而且每一次都是获取同一个对象。从而达到单例的目的。
这种单例模式又叫做饿汉式单例模式，无论如何都会创建一个实例

代码如下：

package com.baidu.demo.test5;

public class Demo7 {
	
	//把构造方法设置成私有的,此时外部类是没办法访问的
	private Demo7() {
		
	}
	
	//准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
	private static Demo7 demo = new Demo7();
	
	//返回实例对象
	public static Demo7 getDemo() {
		return demo;
	}
	
	public static void main(String[] args) {
		
		//通过getDemo得到对象
		Demo7 d1 = Demo7.getDemo();
		Demo7 d2 = Demo7.getDemo();
		Demo7 d3 = Demo7.getDemo();
		
		//通过比较发现，得到的对象是同一个，这就是饿汉式单例模式
		System.out.println(d1 == d2);
		System.out.println(d2 == d3);
		
	}
}

运行结果：
在这里插入图片描述

懒汉式单例模式
懒汉式单例模式与饿汉式单例模式不同，只有在调用得到对象那个方法的时候，才会创建实例
代码演示：

package com.baidu.demo.test5;

public class Demo8 {
	
	//把构造方法设置成私有的,此时外部类是没办法访问的
	private Demo8() {
		
	}
	
	//准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
	private static Demo8 demo;
	
	//返回实例对象；
	public static Demo8 getDemo() {
		//第一次访问的时候，发现demo没有指向任何对象，这时实例化一个对象
		if(demo == null) {
			demo = new Demo8();
		}
		
		return demo;
	}
	
	public static void main(String[] args) {
		
		//通过getDemo得到对象
		Demo8 d1 = Demo8.getDemo();
		Demo8 d2 = Demo8.getDemo();
		Demo8 d3 = Demo8.getDemo();
		
		//通过比较发现，得到的对象是同一个，这就是懒汉式单例模式
		System.out.println(d1 == d2);
		System.out.println(d2 == d3);
		
	}
}

运行结果：
在这里插入图片描述

七、枚举类型

枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量
比如设计一个枚举类型季节，里面有4种常量
代码如下：

package com.baidu.demo.test5;

//枚举类型 季节，里面有4种常量，分别是春、夏、秋、冬
public enum Season {
	SPRING,SUMMER,AUTUMN,WINTER
}

然后再写一个测试类
代码如下：

package com.baidu.demo.test5;

public class Demo9 {

	public static void main(String[] args) {
		
		//枚举的使用
		Season season = Season.SPRING;
		
		//switch判断声明的枚举season的值，并对应打印
		switch (season) {
        case SPRING:
            System.out.println("春天");
            break;
        case SUMMER:
            System.out.println("夏天");
            break;
        case AUTUMN:
            System.out.println("秋天");
            break;
        case WINTER:
            System.out.println("冬天");
            break;
        }

	}

}

运行结果：
在这里插入图片描述
使用枚举的好处：
假设在使用switch的时候，不是使用枚举，而是使用int，而int的取值范围就不只是1-4，有可能取一个超出1-4之间的值，这样判断结果就似是而非了。（因为只有4个季节）

但是使用枚举，就能把范围死死的限定在这四个当中

八、增强型for遍历枚举

还是刚刚的Season枚举
我们进行一个遍历
代码如下：

package com.baidu.demo.test5;

public class Demo10 {

	public static void main(String[] args) {
		
		//增强型的for遍历枚举
		for(Season s:Season.values()) {
			System.out.println(s);
		}

	}

}

运行结果：
在这里插入图片描述

好啦，今天就讲这么多
有问题的QQ497099936
24小时不定时在线解答哦
ok
顾得白

周秃秃

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础第九课（类和对象的讲解）

今天的知识点有点儿多大家耐心点儿哦开始一、引用这个之前就接触过了我这里就直接代码演示吧package com.baidu.demo.test5;public class Demo1 { String name; int age; public static void main(String[] args) { //创建一个对象 new Demo1(); /...
复制链接

扫一扫