大数据的学习路程(java基础学习篇)--TenDay

本文链接：https://blog.csdn.net/keffe/article/details/90523574

1.局部变量一定要初始化
2.String类型不能换算(加减乘除) 所以用Int还是String 要想好,用数组
3.static:类关键字. 优先于类加载,在系统加载时,static,就会开始是初始化,所有被static修饰的变量,都是在系统加载时,初始化
修饰的方法或变量, 直接类名点调用

static的四种用法: 调用方式:修饰的方法或变量(private除外), 直接类名点调用

1.用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享;                         意思:修饰成员变量,所有对象共享,一个改变该变量,全部都变
2.用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；			意思:修饰的方法,调用格式:类名.方法名,避免了先要new出对象的繁琐和资源消耗
3.静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；	意思:把所有关联的类,可以用static代码块,初始化
4.静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便		
5.static修饰的方法中,只能调用static的方法
6.static修饰的变量中,只能调用static的变量
7.非静态的方法中,可以调用静态变量,静态方法
8.没有静态类,只有静态方法
9.内部可以设置静态类



栈                  堆                      

声明-------------->new 对象()
					 |
					 |static修饰的方法,放入方法区
					 |
					 |
					 \/

					方法区(包含static)

1.一个类中,有get…set…与构造方法,该如何调用…?
是用get…set…还是用构造方法?

答:构造方法只是初始化开始要默认定义的值,如果后面想改变值的话,就通过get…set…

疑问:构造方法的初始化,是new一个初始化一次吗? 是的,new一个对象执行一次

2.设计工厂模式:
1.一个方法来代替new关键字:
疑问:
1.是什么:很简单,就是重新创建一个类,然后在这个类中再建一个静态方法,并且用要封装的类作返回值类型
如: Car cat = new BMW(); Car cat = 工厂.Bmw工厂();
Car car = new DaB(); /
|
代替: public class 工厂{
public static BMW Bmw工厂(){
…BMW bmw = new BMW();
return BMW;
}
}
为了兼容更,一般是Car类型(父类)

建工厂的时候,方法的返回值类型,一定要是父类(为了扩展性)
2.为什么要代替?
答:类本身有好多子类，这些类的创建过程在业务中容易发生改变，或者对类的调用容易发生改变
3.代替的好处是什么?
1,为了解耦:将声明与new对象分开,把new交个工厂去处理
2,降低代码重复:
4.场景:
1.对象的创建过程/实例化准备工作很复杂，需要很多初始化参数，查询数据库等

3.单例模式:保证一个类仅有一个实例，并提供一个访问它的全局访问点
只能被自己创建,所以构造器要私有化

疑问:
	1.是什么
	2.好处是什么?
				1.控制资源的使用，通过线程同步来控制资源的并发访问；

2.控制实例产生的数量，达到节约资源的目的。

3.作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

分为:在单例模式中,无聊new多少次,所有对象都是相同的,hashCode相同

	饿汉模式
	
	public class sun{
		1.开始里面放的全是私有化
		2.最后要提供一个访问点
		
		private int i;
		private static Sun Sun = new Sun();//饿汉模式,一开始加载的时候就new了,加个静态的static
		
		私有化构造方法
		private sun(){
		
		}
		
		提供一个访问点
		public static Sun sun (){
			
			return sun
		}
		
	}
	
	好处:static静态的实例化对象,所以在系统加载时,就会实例化对象
		1.无须考虑多线程访问问题，可以确保实例的唯一性
		2.从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例
	
	缺点:
		1.无论需不需要这个单例模式,系统加载时,都会创建对象,所有就会造成加载时间需要较长(效率会低)
	
	
	懒汉模式
	
	public class sun{
		1.私有化
		2.提供访问点
		
		
		私有化
		private Sun sun ;
		private Sun(){}
		
		访问点
		public static Sun getSun(){
			判断一下是否存在Sun对象,不存在,则赋值
			if(Sun == null){
				sun = new Sun();
			}
			return sun;
			
			
		}
		
	}
	
	好处:第一次使用创建,无需一直占用系统资源,实现了延时加载-----系统加载快.
	缺点:在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的机率变得较大


解决方法:用静态内部类
	public class Sun{
		private sun(){}
		//将实例化放入一个静态类中
		private static class HolderSun{
			
			private static final Sun sun = new Sun();
		}
		
		//外部访问点
		public static final Sun getSun(){
			return HolderSun.sun;
		}
	
	}

4.单例模式与工厂模式的区别,使用的场景有哪些?
单例模式:在多线程中,控制对象创建的数量
工厂模式:对象的创建过程