数据开发_Java语言情况

Java的参数传递

1.原理：

值传递会创建副本，引用传递不创建副本，
  实参是基本数据类型的时候创建 副本，
  实参是引用类型的时候创建    地址的副本，即实参对象引用的地址当做值传递给了形式参数
 不会改变的原因：
    1.会new一个String，在把引用交给name，即生成一个新的内存地址，不影响原来的内存地址的数据
	 赋值运算符，赋值的使用了new
	2.改变自身方法的引用类型，对地址的内容进行改变，也即发生了改变

2.状况：

 基本数据类型
 没有提供改变自身方法的引用类型
 提供改变自身方法的引用类型
 提供了改变自身方法的引用类型，但是不使用，而是使用赋值运算符

3.示例

 import java.util.HashSet;
 import java.util.Set;
 
 public class TransDataMain {
     public static void main(String[] args) {
         System.out.printf("");
         Set hashSet = new HashSet();
         hashSet.add(1);
         hashSet.add(2);
         getAssig2(hashSet);
 
         for (Object obj : hashSet) {
             if (obj instanceof Integer) {
                 int aa = (Integer) obj;
                 System.out.println(aa);
             } else if (obj instanceof String) {
                 String aa = (String) obj;
                 System.out.println(aa);
             }
         }
     }
 
     public static void getRandSet( Set hashSet){
             hashSet.add(100000);
         }
 
     public static void getAssig( Set hashSet){
         Set set= hashSet;
         set.add(20000);
     }
 
     public static void getAssig2( Set hashSet){
         Set set= new HashSet();
         set.add(20000);
         System.out.println("########" + set.hashCode());
         System.out.println("########" + set.getClass().getName());
         set = hashSet;
         set.add(300);
         hashSet.add(5000);
         System.out.println(set.getClass().getName());
         System.out.println(set.hashCode());
         System.out.println(hashSet.getClass().getName());
         System.out.println(hashSet.hashCode());
     }
 
 }

Class类

 public class Object {
    public final native Class<?> getClass();
  }

 public final class Class<T> implements java.io.Serializable, GenericDeclaration,
                          Type,AnnotatedElement {
						  }

类型系统（Type System）

类型检查: type-checking
类型推导: type-infernece  类型推导首先建立在基础类型的基础.过程： 归纳（Reduction）合并（Incorporation）解析（Resolution

java.lang.reflect.Type{
  //These include raw types, parameterized types,array types, type variables and primitive types.
  }
 接口: ParameterizedType GenericArrayType WildcardType TypeVariable<D> 还有类: Class
   ParameterizedType 参数化类型
   TypeVariable 类型变量
   GenericArrayType 数组类型且元素是  ParameterizedType 或者 TypeVariable类型
   WildcardType 通配符类型

引用类型

  和JVM相关
 Java.lang.ref 是 Java 类库中比较特殊的一个包，它提供了与 Java 垃圾回收器密切相关的引用类
    Reference 是一个抽象类，而 SoftReference,WeakReference,PhantomReference 以及 FinalReference 都是继承它的具体类
	1.强引用(StrongReference)
	2.广义弱引用
	 SoftReference 在 弱引用 中属于最强的引用
	 WeakReference 是弱于 SoftReference 的引用类型
	 PhantomReference 是所有”弱引用”中最弱的引用类型
	  软引用(SoftReference)
	  弱引用(WeakReference)
	  虚引用(PhantomReference)
          引用类型	取得目标对象方式	垃圾回收条件	是否可能内存泄漏
          强引用	直接调用	        不回收	可能
          软引用	通过 get() 方法	   视内存情况回收	不可能
          弱引用	通过 get() 方法    	永远回收	不可能
          虚引用	无法取得	       不回收	可能
    注意：如果想使用这些相对强引用来说较弱的引用来进行对象操作的时候，
    就必须保证没有强引用指向被操作对象。
    否则将会被视为强引用指向，不会具有任何的弱引用的特性
	FinalReference 作为 java.lang.ref 里的一个不能被公开访问的类
	  FinalReference 代表的正是 Java 中的强引用
	  实际采用了 FinalReference 类对其进行引用。
	  而 Finalizer，除了作为一个实现类外，更是在虚拟机中实现一个 FinalizerThread
   参考： https://developer.ibm.com/zh/articles/j-lo-langref/

Java类型转换

1.各种数据类型的互相转换

 数据类型的转换: 分为自动转换和强制转换
  强制转换的格式是在需要转型的数据前加上"()"，然后在括号内加入需要转化的数据类型
  01.基本类型转换 基本类型
  02.数组 转化为 字符串
  03.

2. 类类型转换

  父类变量向子类转换必须通过显式强制类型转换,同时要求该父类变量是子类的一个实例
    通过instanceof运算符来判断父类变量是否是该子类的一个实例，
	  否则在运行时会抛出运行异常ClassCastException，表示类转换异常

3.接口与类

  # Set是一个接口，而HashSet是一个类。 HashSet继承并实现了Set
  //  便于程序代码的重构. 使用通用共有方法的话，建议少用特性，多用面向接口
  Set set=new HashSet()

语言的类型

Untyped Lambda calculus
   lambda 演算 和图灵机 等价
STLC (Simply Typed Lambda calculus)
   在无类型的 Lambda 演算基础上添加了类型，其语法结构（BNF）
   java.lang

Java语言核心

java.lang.annotation  public interface Annotation {}

java.lang.reflect     public final class Array {}

java.lang             public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {}
java.lang             @Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface Override {}
java.lang             public class Package implements java.lang.reflect.AnnotatedElement {

其他：
  java.util.Arrays    Arrays工具类
  java.util.ArrayList

Java设计模式

 1.创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程
 具体情况：单例模式 原型模式  简单工厂模式  工厂方法模式  抽象工厂模式   建造者模式  
  其中：
   简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。
            简单工厂模式中可以发现在工厂中创建相应的对象是通过条件判断方式，进行选择的方式进行创建
   工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。
   抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。
   建造者模式： 

语法：

词法 ： lexical token

字符集: Unicode 字符集
tokens: These tokens are 
   the identifiers,keywords, literals, separators, and operators of the Java programming languag
   1.Lexical Grammar (词法
       Java源程序由 White Space/ Comment/ Token 三部分构成
	    01.White Space: space . horizontal tab. form feed. Line Terminator
		            其中 Line Terminator有LF(换行) CR(回车) CR LF三种形式。
		02.Comment注释  有 /* text */  和  //text  两种形式 
		    /* text */  多行注释的，可以使用额外的*字符突出注释内容
			/** 特殊的文档注释
		03.Token 划分为 Keyword(关键字) Identifier(标识符) Literal(字面量) 
		          标点符号:   Separator(分隔符) Operator(运算符)
		    标识符 Identifier 命名规则：
			   
		    Literal 是指在源码中表示primitive type、String type、null.
			       直接出现在Java源码中 的值
            Separator 分割符有 12 个 ( ) { } [ ] ; , . … @ ::
            Operator  运算符有 38 个 
                = > < ! ~ ? : -> 
                == >= <= != && || ++ – 
                + - * /  % += -= *= /=   %= 
                << >> >>>  <<= >>= >>>=
                & | ^   &= |= ^= 

		  标识符：
		     java.lang.Character -- 以下两个方法定义可以出现的标识符
		      public final class Character implements java.io.Serializable, Comparable<Character>
			    isJavaIdentifierPart  CharacterData.of(codePoint).isJavaIdentifierPart(codePoint)
				isJavaIdentifierStart
		   Literal：
		        char short int long float double byte
				   boolean true false 
		        String  String类型是类  java.lang.String
				null
		       其中 public final class String implements java.io.Serializable, Comparable<String>, CharSequence

2.句法 syntactic

     流程控制语句
	 try/catch/finally 语句
	 throw 语句
	 synchronized 语句
	 assert 语句
	 方法： 方法是有名称的Java语句序列
  3.类型  类型系统（Type System）
    java.lang.reflect.Type
      * Type is the common superinterface for all types in the Java  programming language. 
	 These include raw types, parameterized types, array types, type variables and primitive types.
	 类型推导（type-infernece）
	   推导过程： 归纳(Reduction) 合并(Incorporation) 解析(Resolution)
	   01.编译时 类型检查
	   02.java 泛型在运行的时候是会进行泛型擦除的 ： 类型擦除
       03.运行时类型
        Type是所有类型的父接口, 泛型出现之后，扩充了数据类型
             原始类型(raw types 对应 Class) 
        	 参数化类型(parameterized types 对应 ParameterizedType) 
			 类型变量  (type variables 对应 TypeVariable ) 
        	 数组类型  (array types 对应 GenericArrayType)   组成元素是 ParameterizedType 或 TypeVariable 类型
        	 基本(原生)类型(primitive types 对应 Class)
     引入了Type这个类型，并且
	  新增了 ParameterizedType, TypeVariable, GenericArrayType, WildcardType四个表示泛型相关的类型，
	  再加上Class，这样就可以用Type类型的参数来接受以上五种子类的实参或者返回值类型就是Type类型的参数。
	  统一了与泛型有关的类型和原始类型Class
	  * WildcardType represents a wildcard type expression, such as {@code ?}, {@code ? extends Number}, or {@code ? super Integer}.
            public interface WildcardType       extends Type {
            public interface ParameterizedType  extends Type {
            public interface TypeVariable<D     extends GenericDeclaration> extends Type, AnnotatedElement {
            public interface GenericArrayType   extends Type {
            
    4.
	  从引用类型中看： 数组 类  接口   枚举 注解
	  从类和接口上来看： 字符串 数组 以及 枚举都是类 ，注解是特殊的接口

字符串

字符串
  public final class String implements java.io.Serializable, Comparable<String>, CharSequence
  public final class StringBuffer  extends AbstractStringBuilder implements java.io.Serializable, CharSequence {
  public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence {

数组：
 java.lang.reflect.Array
    public final class Array {}
        java.util.Arrays

枚举和注解
 java.lang.Enum
     public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
 java.lang.annotation.Annotation
     public interface Annotation {}

不同之处

Python的布尔值 while(i)  if(f)
   以下值在作为布尔表达式的时候，会被解释器看作假(False)
         False    None    0   ""    ()    []   {}
    类型的数字0（包括浮点型，长整型和其他类型），空序列（比如空字符串、元组和列表）以及空的字典都为假。
	其他的一切都被解释为真，包括特殊值True.
Java的布尔值，Java比其他语言对布尔值要求严格， while(i !=0)  if(f != null)

参考：

  The Java  Language Specification  Java 编程语言规范
  参考：
 java.lang.reflect
 javax.lang.model