JAVA基础

一个文件只能有一个public类，文件名要和该类名一样。如果一个文件有多个类，经过编译后会生成多个class 文件，一个类生成一个.class文件

/**/多行注释里不能嵌套

ISO8859-1 西欧字符集

BIG5: 台湾的大五码 表示繁体汉字

GB2312 大陆使用最早 最广的简体中文字符集

GBK GB2312的扩展，可以表示繁体中文

GB18030：最新的GBk扩展

Unicode:国际通用字符集

数据类型：基本数据类型：数值型 (byte,short,int,long,float ,double)，字符型char，布尔型boolean

                    引用数据类型： 类，接口，数组

构造方法：

1.通过new关键字来调用

2.构造器虽然有返回值，但是不能定义返回类型（返回值的类型肯定是本类），不能在构造器里调用return 

3.如果木有定义构造器，则系统会自动调用一个无参的构造函数，如果定义，则编译器不会添加

4.构造器的方法必须和类名一致。

重载：

两同三不同：

同一个类，同一个方法名

不同：类型，个数，顺序不同

只有返回值不同不构成方法的重载

只有形参的名称不同，不构成方法的重载

static:

static声明的成员变量为静态变量，或者叫做类属性，类变量

为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时， 被显示初始化

对于该类的所有对象来说，static 成员变量只有一份，被该类的所有对象共享

static变量位于方法区内

 

int intVar1;
int intVar2;
long var1=intVar1*intVar2 //这里整个表示的值是 int如果 结果超过int则 var1虽然是long但其实在计算的过程整个表达式就溢出了
所以var1 是负值
long var1=(long)intVar1*intVar2 ,整个表达式是long，正确

JDK7.0 新特性
二进制整数：
int a=0b0000_0000_0000_0000_0000_0000_0000_0011; //3 //下划线是分割符

增强switch: 表达式可以是 字符串
String a="你好";
switch(a)
case "你好"
...
case "好呀"
....

抽象类：
有抽象方法的类只能定义为抽象类
抽象类不能实例化(不能用new)
抽象类可以包含属性，方法，构造方法。但是构造方法不能用来new实例化 只能用来被子类调用
抽象类只能用来继承
抽象方法必须被子类实现

 

接口：比抽象类还抽象 只有常量和抽象方法,一个类可以实现多个接口

            接口不能new

            可以声明接口变量 = new实现类，如果要调用实现类中特有的东西，则需要强制转换，和多态差不多

             接口支持多继承

     

public interface myinterface(){

接口中定义常量时 总是有：public static final

String MY_NAME="你好"; //这里默认是 public static final

//权限这里不能改成private ，方法的默认是 public abstract

 void test01();

}

 

支持多继承：

public interface A{void aa();}

public interface B{void bb();}

public interface C extends A,B {void cc();}

如果有个类实现了接口C，则必须实现三个方法

 

内部类：

提供了更好的封装，内部类可以直接访问外部类的私有方法

但外部类不能访问内部类的内部属性

非静态内部类不能有静态方法，静态属性，静态初始化块

静态内部类：

1. 当一个静态内部类存在，并不一定存在对应的外部类对象，因此，静态内部类的实例方法不能直接访问外部类的实例方法。

2.静态内部类看作是一个外部类的静态成员，外部类的方法中可以通过静态内部类.名字，访问静态内部类的静态成员。通过new静态内部类()访问静态内部类的实例

**
 * 测试内部类的使用
 * @author dell
 *
 */
public class Outer {
 public static void main(String[] args) {
  Face f = new Face(); //重点
  Face.Nose n = f.new Nose(); // 重点
  n.breath(); //重点
  Face.Ear e = new Face.Ear();
  e.listen();
 }
}

class Face {
 int type;
 String shape="瓜子脸";
 static String color="红润";
 
 class Nose {
  void breath(){
   System.out.println(shape); //如果自己木有type可以直接写   

   System.out.println(Face.this.type);  //重点。。。 

   System.out.println("呼吸！");
  }
 }
 static class Ear {
  void listen(){
   System.out.println(color);
   System.out.println("我在听！");
  }
 }
}

 

 

数组：初始化规则和成员变量初始化规则一样

int []a= new int [3]

 初始化：默认初始化和类的成员变量一样的规则
动态初始化：
静态初始化： int c[] = {33,23,33,44};
             Car[] cars = {
      new Car("奔驰"),
      new Car("比亚迪"),
      new Car("宝马")
     };

     
StringBuilder:线程不安全 效率高
StringBuffer:线程安全 效率低

包装类：
-128，127之间的数，仍当作基本数据类型来处理

 

 

接口：

 * 泛型类:声明时使用泛型
 * 字母：
 * T  Type 表示类型。
 K V 分别代表键值中的Key Value。
 E 代表Element。
 使用时确定类型
 注意：
 1、泛型只能使用引用类型，不能基本类型
 2、泛型声明时字母不能使用 静态属性|静态方法上

 

接口中

   泛型字母只能使用在方法中，不能使用在全局常量中 

  泛型方法 <> 返回类型前面
  只能访问对象的信息，不能修改信息

 

 

 /**
 * 父类为泛型类
 * 1、属性
 * 2、方法
 *
 * 要么同时擦除，要么子类大于等于父类的类型,
 * 不能子类擦除，父类泛型
 * 1、属性类型
 *  父类中，随父类而定
 *  子类中，随子类而定
 * 2、方法重写:
 *  随父类而定
 *
 *
 * @author Administrator
 *
 * @param <T>
 */
public abstract class Father<T,T1> {
 T name;
 public abstract void test(T t);

}
/**
 * 子类声明时指定具体类型
 * 属性类型为具体类型
 * 方法同理
 */
class Child1 extends Father<String,Integer>{
 String t2;
 @Override
 public void test(String t) {
 } 
}
/**
 * 子类为泛型类 ,类型在使用时确定
 * @author Administrator
 *
 */
class Child2<T1,T,T3> extends Father<T,T1>{
 T1 t2;

 @Override
 public void test(T t) {
  
 }
 
 
}
/**
 * 子类为泛型类，父类不指定类型 ,泛型的擦除，使用Object替换
 */
class Child3<T1,T2> extends Father{
 T1 name2;
 @Override
 public void test(Object t) {
  // TODO Auto-generated method stub  
  
 }
 
}
/**
 * 子类与父类同时擦除
 */
class Child4 extends Father{
 String name; 
 @Override
 public void test(Object t) {
  
 }
 
}
/**
 *错误:子类擦除，父类使用泛型
class Child5 extends Father<T,T1>{
 String name; 
 @Override
 public void test(T t) {
  
 }
*/
 

泛型木有多态

通配符：? extends super

1.可以用在声明类型及声明方法参数上，不能用在声明类上

2.？可以接受泛型的任意类型，只能接受和输出 不能修改

         方法声明时候参数无法正确知道具体的类型，因此不能修改

3. ?extends 泛型上限 <=

4. ?super    泛型下限  >=

 

没有泛型数组，不能创建泛型数组

可以只有声明，可以使用？

A<String>[]a1=null;

A<?>[]a2= new A<?>[10];

public class Array {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Integer[]  arr = new Integer[4];
  //Student<String>[] arr2 = new Student<String>[10];
  Student<?>[] arr2 = new Student[10];
  
  MyArrayList<String> strList =new MyArrayList<String>();
  strList.add(0, "a");
  String elem =strList.getElem(0);
  System.out.println(elem);
  
  
 
  
 }

}
class MyArrayList<E>{
 //E[] cap =new E[10]; 没有泛型数组
 Object[] cap = new Object[10];
 
 public void add(int idx,E e){
  cap[idx] =e;
 }
 
 
 @SuppressWarnings("unchecked")
 public E[] getAll(){
  return (E[]) cap;
 }
 @SuppressWarnings("unchecked")
 public E getElem(int idx){
  return (E) cap[idx];
 }
}

 

 

/**
 * 1.7中使用泛型，声明一次类型即可
 * 在使用|创建时不用指定类型
 * @author Administrator
 *
 */
public class Test7 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  List<String>  arrList= new ArrayList<String>();
  //List<String>  arrList2= new ArrayList<>();
 }

}

 

增强for循环，必须实现Iterable接口，实现iterator方法 才能用增强for循环