java基础

2017.2.26

Java 基础

1 ==与equals

==比较的是变量指向的地址，equals比较的是指向的内容

2 String

一个字符串就是String的一个匿名对象 System.out.println("".getClass()); //class java.lang.String

String采用直接赋值的方式的时候，如果字符串相等，就不需要重新开辟空间，此时==结果也是true，使用直接赋值的方法可以节省空间。使用new String会开辟多个实例空间。 String s=new String("123")这里开辟了两个String空间，其中第一个“123”是垃圾空间，要赋值给new 出来的String

字符串的内容不可以改变！！
这个特性在String作为参数进行传引用调用的时候要注意，传引用String本身的值是不会发生变化的
str=“hello”；
str=str+“world!”;
这里会出现三个字符串的实例，+不是改变字符串，而是改变引用的关系，开发中不要这么写！用StringBuffer最好了

3 this

• 表示类中属性
• 表示本类的构造方法
  注意只能是用在一个构造方法里面去调用另一个构造方法
• 表示当前对象
  指的是当前调用的方法的对象，这个可以和1类比，this十分灵活，指的就是当前的这个操作的对象

4 static 类方法

对应的是类方法或者类属性，那么每一个实例都指向他这一个 全局数据域。
在没有实例化之前，静态的方法/属性就饿可以被调用了
可以用static来统计示例个数或者给对象编名字
static方法只能调用static的属性或者方法

5 exit

system.exit(status)
status为0表示程序正常退出，为非零表示程序非正常的退出

6 代码块

class _代码块Demo{
        //静态代码块
        static {
            System.out.println("静态代码块");
            //用于静态变量的初始化
        }

        {
            System.out.println("构造代码块");
        }

        public _代码块Demo() {
            System.out.println("构造函数");
        }

        public static void STATICFUNC(){
            System.out.println("静态函数");
        }
}
public class _代码块 {
    static{
        System.out.println("主类中的静态代码块");
    }
    public static void main(String[] args) {

        _代码块Demo.STATICFUNC();

        new _代码块Demo();
        //    主类中的静态代码块
        //    静态代码块
        //    静态函数
        //    构造代码块
        //    构造函数
        }
}

1. 静态代码块
   在第一次执行类的时候调用一次，多用于静态变量的初始化
   调用场景包括第一次实例化类、第一次调用静态方法。是最先执行的，在构造代码块之前执行
2. 构造代码块 是在构造函数之前执行的，没new一次执行一次
3. 普通代码块

7 构造方法私有化

单例模式

    //单例模式，将构造方法私有化，在类的内部实例化方法，这样不管外部定义了多少个变量，实际上对应的都是一个实例。
    class _Single{
        private static _Single instance=new _Single();
        public  static _Single getInstance(){
            return  instance;
        }
        private _Single() {
            //构造方法私有化
        }
        public void print(){
            System.out.println("打印");
        }
    }
    public class _构造方法私有化_单例模式 {
        public static void main(String[] args) {
            _Single s1=_Single.getInstance();
            _Single s2=_Single.getInstance();
            _Single s3=_Single.getInstance();
            s1.print();
            s2.print();
            s3.print();
        }
    }

8 内部类

• 缺点：破环了结构，内部类是不能再外面直接调用的

• 有点：降低代码的复杂度，可以方便的访问外部类的私有属性 class outer{

      private String s="hello world";
  
      class inner{
          //内部类，可以直接调用它的外部类的私有属性
          public void fun(){
              System.out.println(s);
          }
      }
  
      public void fun(){
          new inner().fun();
      }
  
      public void  fun1(final int  temp){
          //定义在函数里面的内部类
          class inner1{
              public void fun(){
                  System.out.println(s);
              }
          }
          new inner1().fun();
          System.out.println("参数"+temp);
      }
  }
  
  public class _内部类 {
      public static void main(String[] args) {
          //两种方法来从外部执行内部的方法
  
          outer outer=new outer();
          outer.fun();
  
          outer.inner in=outer.new inner();
          in.fun();
  
          outer.fun1(21);
      }
  }   
  

9 继承

10 Object

Object是所有类的父类
equals()
hashCode()
toString() --在直接打印对象的时候会调用此方法

Object可以用于接受任意的引用类型，包括类/数组/接口

11 包装类

将8种基本数据类型包装起来
Integer Byte Float Double Short Long是Number的子类
Boolean和Character是Object的子类
Number的byteValue()之类方法的可以取出基本的数据类型 自动装箱拆箱可以对于包装类直接进行+ - 操作

    Integer i=30；自动封箱
    int x=i;自动拆箱

Integer.parseInt
Float.parseFloat

11 包

命名 包名称.子包名称 定义了包之后 类名称就是包名称.类名称
javac -d . a.java 生成的class按照包的结构存放
包的意义就是，每一个包就是在一个文件夹下，这样多人开发的时候在不同的包下可以有同名文件 java org.mm.packDemo执行的时候要写完整包名

包就是packet定义，import引入(引入的是类),(注意加分号) 只有public的类才能被外包引用，一个.java里面只能有一个public的类

导入包得的时候，使用*不会影响效率，JVM会决定要导入哪些类

注意：如果你导入的多个包中有同名的类，在使用该类的时候会有冲突，这时候要使用【完整的包名.类名】 来决定具体是哪一个类

常见的包

java.lang String/包装类/SyStem 这个包自动导入
java.lang.reflect 反射机制
java.util 包名
java.text
java.sql
java.net
java.io java.awt
javax.swing

静态导入

如果类方法都是静态的
import static 包.类.*
这样使用的时候 不用 类.方法(),直接使用方法()就可以了

jar

jar要想使用的话，要配置classpath路径
set classpath=d:q.java

12 访问权限

范围	private	default	protected	public
同一类	Yes	Yes	Yes	Yes
同一包		Yes	Yes	Yes
不同包的子类			Yes	Yes
其他包的类				Yes

public：可以被所有其他类所访问

private：只能被自己访问和修改

protected：自身、子类及同一个包中类可以访问

default：同一包中的类可以访问

13 命名规范

类：单词首字母大写
方法：第一个单词首字母小写,之后单词首字母大写
属性：第一个单词首字母小写,之后单词首字母大写
包：全部小写
常量：全部大写