一个文件只能有一个public类,文件名要和该类名一样。如果一个文件有多个类,经过编译后会生成多个class 文件,一个类生成一个.class文件
StringBuilder:线程不安全 效率高
StringBuffer:线程安全 效率低
包装类:
-128,127之间的数,仍当作基本数据类型来处理
/**
* 1.7中使用泛型,声明一次类型即可
* 在使用|创建时不用指定类型
* @author Administrator
*
*/
public class Test7 {
/**/多行注释里不能嵌套
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,正确
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 //下划线是分割符
二进制整数:
int a=0b0000_0000_0000_0000_0000_0000_0000_0011; //3 //下划线是分割符
增强switch: 表达式可以是 字符串
String a="你好";
switch(a)
case "你好"
...
case "好呀"
....
String a="你好";
switch(a)
case "你好"
...
case "好呀"
....
抽象类:
有抽象方法的类只能定义为抽象类
抽象类不能实例化(不能用new)
抽象类可以包含属性,方法,构造方法。但是构造方法不能用来new实例化 只能用来被子类调用
抽象类只能用来继承
抽象方法必须被子类实现
有抽象方法的类只能定义为抽象类
抽象类不能实例化(不能用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();
}
}
* 测试内部类的使用
* @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可以直接写
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("我在听!");
}
}
}
}
}
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("宝马")
};
动态初始化:
静态初始化: 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、泛型声明时字母不能使用 静态属性|静态方法上
* 字母:
* 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);
* 父类为泛型类
* 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;
/**
* 子类声明时指定具体类型
* 属性类型为具体类型
* 方法同理
*/
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) {
}
*/
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);
}
* @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];
}
}
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<>();
}
* @param args
*/
public static void main(String[] args) {
List<String> arrList= new ArrayList<String>();
//List<String> arrList2= new ArrayList<>();
}
}
增强for循环,必须实现Iterable接口,实现iterator方法 才能用增强for循环