今天的知识点有点儿多
大家耐心点儿哦
开始
一、引用
这个之前就接触过了
我这里就直接代码演示吧
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
顾得白