Java 面向对象 day3

于 2021-01-19 20:24:42 发布
阅读量1k 收藏
点赞数
分类专栏： Java面向对象 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43794494/article/details/112849665
版权

Java 面向对象 day3

Java 面向对象 day3

构造方法

一.定义

指定义在类中的一种特殊的方法,该方法没有返回值,方法名要与类名相同,可以使用参数,用于创建对象.

二.作用

完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。

一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。

每一个类创建时,系统都会默认的提供一个无参构造方法.当定义带参构造方法后,系统会默认取消无参构造方法.所以需要显示定义无参构造方法

三.格式

访问修饰符 构造方法名(参数列表){
[初始化对象代码;]
}

默认构造方法

1.隐含的默认构造方法

public Car() {}

2.显示的默认构造方法

public Car() {
		System.out.println("这是一个默认构造方法");
	}

重载构造方法

比如原本的类里的构造方法是没有参数的，现在新建的对象是有四个参数，此时就要重载构造方法

public Car(String No,String name,String brand,double price) {
		this.No = No;
		this.name = name;
		this.brand = brand;
		this.price = price;
}

构造方法的调用

public void show() {
		Car car = new Car("粤C.****", "X6", "BMW", 90);
	}

方法的重载

一.定义

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或参数类型不同，与方法的返回值无关。

二.重载的示例

public class Sum {
    public static void main(String[] args) {
        Sum s1 = new Sum();
        System.out.println(calculate(10));
        System.out.println(calculate(15,25.3));
        System.out.println(calculate(23,36));
    }

    public static int calculate(int num1){
        return num1;
    }

    public static int calculate(int num1,int num2){
        return num1+num2;
    }

    public static double calculate(int num1,double num2){
        return num1+num2;
    }
}

方法的封装

一.定义

1.方法就是一种封装
2.关键字private也是一种封装

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性，这个就是Java封装方法。

二.演示

问题描述：定义Person的年龄时候，无法阻止不合理的数值被设置进来。
解决方案：用private关键字将需要保护的成员变量进行修饰。

代码演示
Person.java

public class Person {

    public int age;

    public int getAge() {
        return age;
    }

	//通过set方法保证了数据的安全
    public void setAge(int age) {
        if (age>0&&age<130){
            this.age = age;
        }else{
            System.out.println("年龄输入错误,默认值为18");
            this.age = 18;
        }

    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

PersonTest.java

import java.util.Scanner;

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        Scanner sc = new Scanner(System.in);
        pc:
        while (true) {
            System.out.print("请输入年龄：");
            //封装后，属性的赋值,只能通过set方法进行
            p1.setAge(sc.nextInt());
            System.out.println(p1.toString());
            System.out.println("是否继续输入？");
            String s1 = sc.next();
            if (s1.equals("y")) {
                continue;
            } else {
                break pc;
            }
        }
    }
}

运行演示

请输入年龄：23
Person{age=23}
是否继续输入？
y
请输入年龄：89
Person{age=89}
是否继续输入？
y
请输入年龄：-10
年龄输入错误,默认值为18
Person{age=18}
是否继续输入？
n

三.在idea中快速定义封装方法

快捷键 Alt+Insert
在这里插入图片描述
选择Getter and Setter
在这里插入图片描述
选择需要定义的参数，点击OK，即可得到如下代码。

public class Person {
    public int age;

	//get方法是获取,从对象获取内容出去
    public int getAge() {
        return age;
    }

	//从外部设置一个数据到属性中
    public void setAge(int age) {
        this.age = age;
    }
}

单例设计模式：饿汉式与懒汉式

一.单例模式的特点

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

二.饿汉式与懒汉式

1.懒汉式单例模式

public class LazyModule {
    public static void main(String[] args) {
        Cust cust1 = Cust.getCust();
        Cust cust2 = Cust.getCust();
        System.out.println(cust1 == cust2);//true
    }
}

//懒汉式单例类.在第一次调用的时候实例化自己
class Cust {
    static Cust cust = null;
    private Cust() {
    }

    //静态工厂方法
    public static Cust getCust() {
        if (cust == null) {//判断对象是否为null值
            cust = new Cust();
        }
        return cust;
    }
}

2.饿汉式单例模式

public class HungarySingle {

    //1.私有化构造器：不让外界创建实例化对象
    private HungarySingle(){}

    //2.在类的内部创建静态的类的对象
    private static HungarySingle instance = new HungarySingle();

    //提供公用的静态方法,返回类的对象
    public static HungarySingle getInstance(){
        return instance;
    }
}

public class TestHungary {

    public static void main(String[] args) {
        HungarySingle h1 = HungarySingle.getInstance();
        HungarySingle h2 = HungarySingle.getInstance();

        //判断h1和h2是否是同一个对象
        System.out.println(h1==h2);//true
    }
}

static关键字

User.java

public class User {

	//使用static修饰的属性,属于类属性,但是可以被对象所共享
	//一般静态内容不会被设置为私有内容
	private static int id;
	private String name;
	private String password;

	public User() { }
	
	public User(int id,String name, String password) {
		this.id = id;
		this.name = name;
		this.password = password;
	}

	public static int getId() {
		return id;
	}
	
	public static void setId(int ids) {
		id = ids;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

一.修饰成员变量/修饰成员方法

同C++是一样的概念。但是在JVM里面，JVM也会划分一个暂称静态存储区，用于存放方法的定义。实际上从更大的角度而言，它存放的是各种类的定义，当我们通过new来生成对象时，会根据这里定义的类的定义去创建对象。
TestStatic.java

public class TestStatic {

	@Test
	public void show() {
		//以前设置的非static属性及方法都是属于对象的,必须创建对象后才可以使用
		//类属性,可以直接被类使用,对数据进行共享
		com.gec.project.statics.User.setId(100);
		User user = new User();
		user.setId(400);
		user.setName("liWei");
		
		User user1 = new User();
		user1.setId(500);
		user1.setName("pengpeng");
		
		System.out.println("用户ID:"+user.getId()+" ,用户名为:"+user.getName());
		System.out.println("用户1ID:"+user1.getId()+" ,用户名为:"+user1.getName());
	}
}

运行结果

用户ID:500 ,用户名为:liWei
用户1ID:500 ,用户名为:pengpeng

结论：通过运行结果，可以看到 ID都为500，只保存了最后一次给ID赋的值。这是为什么呢，在内存里面发生了什么？

给ID属性加了static关键字之后，User对象就不再拥有ID属性了，ID属性会统一交给User类去管理，即多个User对象只会对应一个ID属性，一个对象如果对ID属性做了改变，其他的对象都会受到影响。

二.静态块（static{}）

（1） static关键字还有一个比较关键的作用，用来形成静态代码块（static{}(即static块)）以优化程序性能。

（2） static块可以置于类中的任何地方，类中可以有多个static块。

（3） 在类初次被加载的时候执行且仅会被执行一次（这是优化性能的原因！！！），会按照static块的顺序来执行每个static块，一般用来初始化静态变量和调用静态方法。
UserArray.java

public class UserArray {

	public static User[] users = new User[10];
	//静态代码块,在类被使用时会执行静态代码块中的内容
	static {
		User user = new User(1001,"zhangsan","569");
		User user1 = new User(1001,"lisi","259");
		User user2 = new User(1001,"wangwu","63");
		User user3 = new User(1001,"zhaoliu","85");
		users[0] = user;
		users[1] = user1;
		users[2] = user2;
		users[3] = user3;
	}
	
	public void addUser(User user) {
		for (int i = 0; i < users.length; i++) {
			if(users[i]==null) {
				users[i] = user;
				break;
			}				
		}
	}
}

注意：强调一下static块是会按照顺序执行，与main入口函数无关。

TestUser.java

public class TestUser {

	public static void main(String[] args) {
		/*
		 * 对象加载的顺序,有限加载类中的内容,在进行实例化
		 * 类可以直接使用所有非私有的static属性及方法
		 */
		User[] users = UserArray.users;
		for (User user : users) {
			if(user!=null)
				System.out.println("用户ID为:"+user.getId()+" ,用户名:"+user.getName()+" ,密码为:"+user.getPassword());
		}
		//不管是对象还是类,操作的是同一个元素(数组)
		UserArray ua = new UserArray();
		User user1 = new User(1569, "xiaoping", "123");
		ua.addUser(user1);
		UserArray ua1 = new UserArray();
		User user2 = new User(1569, "wuhua", "123");
		ua1.addUser(user2);
		
		System.out.println("添加用户后:");
		for (User user : users) {
			if(user!=null)
				System.out.println("用户ID为:"+user.getId()+" ,用户名:"+user.getName()+" ,密码为:"+user.getPassword());
		}
	}
}

运行结果

用户ID为:1001 ,用户名:zhangsan ,密码为:569
用户ID为:1001 ,用户名:lisi ,密码为:259
用户ID为:1001 ,用户名:wangwu ,密码为:63
用户ID为:1001 ,用户名:zhaoliu ,密码为:85
添加用户后:
用户ID为:1569 ,用户名:zhangsan ,密码为:569
用户ID为:1569 ,用户名:lisi ,密码为:259
用户ID为:1569 ,用户名:wangwu ,密码为:63
用户ID为:1569 ,用户名:zhaoliu ,密码为:85
用户ID为:1569 ,用户名:xiaoping ,密码为:123
用户ID为:1569 ,用户名:wuhua ,密码为:123

总结

以上就是今日要分享的内容，其中包括对构造方法的理解，方法的封装与重载的使用，简单介绍了单例模式，深入了解了static关键字。希望这些内容可以为你们学习Java提供一点帮助。

鹏鹏程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值