===============java相关讲解=============
main函数的详解：
public ： 公共的。 权限是最大，在任何情况下都可以访问。
原因： 为了保证让jvm在任何情况下都可以访问到main方法。
static: 静态。静态可以让jvm调用main函数的时候更加的方便。不需要通过对象调用。
void: 没有返回值。 因为返回的数据是 给 jvm，而jvm使用这个数据是没有意义的。所以就不要了。
main: 函数名。 注意： main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。
arguments ：担心某些程序在启动需要参数。
class Demo4 {
public static void main(String[] args)
{
System.out.println("数组的长度："+ args.length);
for(int i = 0 ; i <args.length ; i++){
System.out.print(args[i]+",");
}
Scanner scanner = new Scanner(System.in);
}
}单例设计模式
单例设计模式的步骤：
饿汉单例设计模式
- 私有化构造函数。
- 声明本类的引用类型变量，并且使用该变量指向本类对象。
- 提供一个公共静态的方法获取本类的对象。
懒汉单例设计模式：
- 私有化构造函数。
- 声明本类的引用类型变量，但是不要创建对象，
- 提供公共静态 的方法获取本类 的对象，获取之前先判断是否已经创建了本类 对象
，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，
然后再返回。
推荐使用： 饿汉单例设计模式。 因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。
//饿汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
class Single{
//声明本类的引用类型变量，并且使用该变量指向本类对象
private static Single s = new Single();
//私有化构造函数
private Single(){}
//提供一个公共静态的方法获取本类的对象
public static Single getInstance(){
return s;
}
}//懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
class Single2{
//声明本类的引用类型变量，不创建本类的对象
private static Single2 s;
//私有化了构造函数
private Single2(){}
//
public static Single2 getInstance(){
if(s==null){
s = new Single2();
}
return s;
}
}java继承
继承：继承是通过关键字extends体现的。
继承的格式：
class 类名1 extends 类名2{
}
继承要注意的事项：
- 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
- 父类私有的成员不能被继承。
- 父类的构造函数不能被继承。
- 创建子类对象时默认会先调用父类无参的构造函数。
//人类
class Person{
String name;
private int age;
public Person(String name){
this.name = name;
}
public Person(){
System.out.println("Person类的构造方法被调用了....");
}
public void eat(){
System.out.println(name+"在吃饭...");
}
}
//学生类
class Student extends Person { // Student 就称作为Person类的子类， Person类就称作为Student的父类(超类、基类)
int num; //学号
public Student(){
System.out.println("Student类的构造方法被调用了....");
}
public void study(){
System.out.println(name+"good good study , day day up");
}
}
疑问： 为什么要调用父类的构造方法啊？这样子做的意义在那？
调用父类 的构造方法是可以初始化从父类继承下去的属性的。
class Fu{
int x = 10;
String name;
public Fu(String name){
this.name = name;
System.out.println("Fu类d带参的构造方法...");
}
public Fu(){
System.out.println("Fu类无参的构造方法...");
}
}
class Zi extends Fu{
int x = 20;
public Zi(String name){
super(name); //指定调用父类一个参数的构造函数。
}
public void print(){
System.out.println("x1 = "+ x);
}
}
class Demo8 {
public static void main(String[] args)
{
Zi z = new Zi("大头儿子");
System.out.println("name= "+z.name);
}
}instanceof 关键字
instanceof关键字的作用：判断一个对象是否属于指定的类别。
instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。
-
instanceof关键字的使用格式：
`对象 instanceof 类别` 一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的。
class Demo{
public static void main(String[] args)
{
Dog d = new Dog("哈士奇","白色");
System.out.println("狗是狗类吗？"+ (d instanceof Dog));
System.out.println("狗是动物类吗？"+ (d instanceof Animal));
//System.out.println("狗是老鼠类吗？"+ (d instanceof Mouse));
Animal a = new Animal("狗娃","黄色"); //狗娃是人
System.out.println("动物都是狗吗？"+ (a instanceof Dog));
}
}——————————————————————————————————————————————————
===============与上方java相关的iOS技术关联理解==========
ios程序启动原理
iOS单例 –Singleton
单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
单粒：保证程序运行过程中，永远只有一个对象实例
目的是：全局共享一份资源、节省不必要的内存开销
单例的特点：
- 1.单例对象可以存储一些共享的信息，每个对象都能访问和修改
- 2.如果一个类的创建非常耗费性能，那么这个类最好设计为单列，只创建一次，节约性能；
缺点：单例对象一旦建立，对象指针是保存在静态区的，单例对象在堆中分配的内存空间，会在应用程序终止后才会被释放；
#import "ServiceManager.h"
static ServiceManager *defaultManager;
@implementation ServiceManager
+(ServiceManager *)defaultManager{
if(!defaultManager)
defaultManager=[[self allocWithZone:NULL] init];
return defaultManager;
}
@end#import "ServiceManager.h"
@implementation ServiceManager
+(ServiceManager *)sharedManager{
static dispatch_once_t predicate;
static ServiceManager * sharedManager;
dispatch_once(&predicate, ^{
sharedManager=[[ServiceManager alloc] init];
});
return sharedManager;
}
@end