java基础（类到集合）随记

输入语句：
java.util.Scanner
Scanner input=new Scanner(System.in);//
int one=input.nextInt();
//nextByte(),nextDouble(),nextFloat,nextInt(),nextLine(),nextLong(),nextShot()　
nextLine() 得到一个String类型的数据。

new一个对象时：例Cat cat = new Cat;等号前是在栈中分配一块名为cat的区域，区域内为NULL，等号后是在堆中分配一块区域，等号赋值后，栈中的区域内为堆中的区域名

1.如果两个包中有类名一样的类，导包时一个导包名.*，一个导包名+类名，同名的类在创建对象时，创建的是前面导包名+类名的对象

<static关键字>
2.static修饰一个变量：1.只有当这个类不再有任何对象时，这个变量才能被释放，比较长寿
2.类的成员方法可以直接访问静态成员（变量或者方法）
3.当定义多个对象时，静态变量的值取决于最后一次修改此变量的值，即new多个对象时，多个对象的静态变量占用的是同一块内存
3.static修饰一个方法：静态方法中不能访问同一个类的非静态成员（变量或者方法），只能在方法中实例化这个类后，通过对象.方法名调用非静态成员（变量或者方法）
4.static修饰父类的方法时，子类不能重写，即static修饰的方法只能在类中使用

<代码块>
4.构造代码块：在类中 {代码} 构造代码块在创建对象调用构造方法前调用，可有多个
5.普通代码块：在类方法中 {代码} 此代码块在调用此方法时执行，代码块执行顺序按编写顺序
6.静态代码块：1.在类中 static{代码} 静态代码块的执行顺序先于构造代码块
       2.无论实例化几个对象，静态代码只执行一次
       3.静态代码块不能给普通成员变量赋值，只能在方法中实例化这个类后，通过对象.变量名调用非静态变量
注（执行顺序）：静态代码块 > 构造方法代码块 > 构造方法 > 方法（普通代码块和方法中的代码按顺序执行）
例：public void run()
{
//普通代码块一
{
  int temp=12;
  System.out.println("temp="+temp);
}
int temp=14;//2.这时普通代码块二变量会报错，因为在定义变量后，变量的作用范围从定义变量到方法结束
System.out.println("temp="+temp);//（没有上面定义temp变量的语句）这地方会报错在方法中独立出来了两块代码块，这两块代码块每块分出来一块存放temp变量，在代码块外部不能访问此变量，如果再定义temp变量（即上面定义temp变量的语句），会出现上面 2 的错误
//普通代码块二
{
  int temp=13;
  System.out.println("temp="+temp);
}
}

<继承extends 抽象类abstract>
7.this();只能放在带参构造函数第一行，指的是调用该类的无参构造方法
8.父类的的构造方法不能被继承，不能被重写，可以在子类构造方法的第一行调用父类的构造方法使用super();如果调用有参的在()中加上参数
9.new一个子类对象时：父类的静态代码块->子类静态代码块->父类对象构造（构造代码块，构造方法）->子类对象构造（构造代码块，构造方法），如果子类构造方法第一行没有调用父类的构造方法，默认调用父类的无参构造方法
10.new一个子类对象时，父类一定要有无参构造函数
11.子类方法重写时，子类方法修饰符 >= 父类方法修饰符，public > protected > 默认 > private
12.static修饰父类的方法时，子类不能重写，即static修饰的方法只能在类中使用
13.static与this不可共存

<final关键字>
12.final修饰类时，不能有子类
13.final修饰方法，方法不能被重写
14.final修饰变量，变量值不能修改，变量的初始化要么在定义的时候初始化，要么在构造方法或者构造代码块中初始化
15.final修饰对象，对象不能被赋值，但类中的变量可以通过对象修改，
例：final Cat cat=new Cat;
cat=new Cat;//这句会报错
cat.name="小猫";这句话不会报错
16.final不能修饰构造方法

17.@Override注解重写父类的方法

<类型转换>
18.向上转型（父类引用子类实例）：Animal one=new Cat();父类引用子类对象，可以调用父类的方法或者子类重写父类的方法，但不能调用子类的方法
19.向下转型（将父类引用转换为子类实例）：Animal one=new Cat();Cat cat=(Cat)one;这时候可以强制转换，子类引用父类对象，可以调用子类特有的方法
20.instanceof运算符，可以判断父类对象是否由子类对象转型
例：Animal one=new Cat();
if(one instanceof Cat)
{
Cat cat=(Cat)one;//如果one具有Cat特征，括号里为ture
}
注意：
Animal one=new Cat();
if(one instanceof Animal)
{
System.out.println("Animal")//这句话会输出
}
同样：
Animal one=new Cat();
if(one instanceof Object)
{
System.out.println("Object")//这句话也会输出
}

<java 1.8新增的特殊接口方法>
21.注意：1.java 8（jdk1.8）之后，可以在接口中包含一些带方法体夫人默认方法,默认方法前加default，2.默认方法在实现接口类中可以不用实现，3.调用默认方法：接口类名.supper.默认方法
22.注意：1.java 8（jdk1.8）之后，可以在接口中定义一些带方法体的静态方法，静态方法前加static，2.静态方法在实现接口类中可以不用实现，3.调用静态方法：接口类名.静态方法

<成员内部类>
22.成员内部类(类中再定义类):1.实例化方法，例：Person.Heart myHeart=new Person().new Heart()，2.如果类和测试类不在同一个包里，要是还想使用上面的实例化方法，内部类必须使用public修饰,3.内部类可以直接访问外部类的成员，如果内部类定义了同名属性时，优先使用内部类的属性
23.注：1.外部类不能直接访问内部类的属性和方法，2.如果外部类想访问内部类的属性和方法，只能通过实例化内部类，通过内部类对象调用内部类的属性和方法，3.内部类编译后的.class文件命名为：外部类$内部类.class
24.静态内部类：内部类用static修饰，实例化方法，例：Person.Heart myHeart=new Person().Heart()

<方法内部类>
25.方法内部类（方法中定义类），1.内部类不能添加public private protected static 2.类中不能包含静态成员（属性和方法），3.一般是在方法体返回new 内部类对象.方法调用内部类方法

<匿名内部类>
26.父类生命了是抽象类或者接口类，但没有实现的类，在main函数中调用函数，且传父类对象参数的括号中，new 构造方法(){
实现父类的抽象方法
}
27.适用情况，1.只用到类的一个或极少个对象，2.类在定义后马上用到
28.注：1.在匿名内部类中不能编写构造方法，但可以添加构造代码块，2.不能出现静态成员

<异常>
28.Throwable(Error和Exception),1.Error:程序无法处理的错误，例虚拟机错误，内存溢出，线程死锁，2.Exception(Unchecked Exception和Checked Exception):程序本身可以处理的异常,3.Unchecked Exception(非检查异常)：编译器不要求强制处理的异常，RuntimeException [ NullPointException(空指针异常),ArrayIndexOutOfBoundsException(数组下标越界异常),ArithmeticException(算数异常),ClassCastException(类型转换异常)等等]，4.Checked Exception(检查异常):编译器要求处理的异常，除了RuntimeException 和其子类异常，其他的均属于检查异常，例：IOException,SQLException
29.try catch finally：try中为可能出现的代码，catch中为捕获异常后执行的代码，finally中为无论什么都执行的代码
30.try{
可能出错的代码
}catch(Exception e){
e.printStackTrace()//输出出错信息英语单词意思为:输出堆栈跟踪
}
31.一个try后可有0个或多个catch，但try后必须存在catch或finally的其中一个,需要注意，一般多个catch的最后一个catch块通常是上面的写法
32.System.exit(1);//终止程序运行，括号里为非零的数如果在catch块中添加这句话，以后的及fnally块中的代码不会被执行
33.注：当try catch finally中都存在return语句时，因为finally的强制执行，try catch的return语句不执行而是执行finally中的return语句
34.throws 抛出异常，在调用的时候处理异常，即在调用的时候使用try catch处理异常
35.throw 抛出异常例：throw new IOException(),只能是可抛出异常类Throwable或者其子类的实例对象(Error和Exception详见28)例，throw new Exception("性别必须为女")

<包装类>
36.包装类及对应的包装类：byte -> Byte; short -> Short; int -> Integer; long -> Long; float -> Float; double -> Double; char -> Character; boolean -> Boolean
37.基本数据类型转换为字符串：int t1=2;String t2=Integer.toString(t1);
38.字符串转换为基本数据类型：1.int t3=Integer.parseInt(t2);2.int t4=Integer.valueOf(t2);
39.包装类的初始值为 null
40.Integer one = 100; //实际执行的是 Integer one = Integer.valueOf(100);
Intefer two = 100; //实际执行的是 Integer two = Integer.valueOf(100);当-128 < 参数 <127时，会从缓存区（对象池）中查找，one == two的结果为 true
41.Integer three = 200;Integer four = 200; three == four的结果为false,如果参数不在-128 < 参数 <127范围内，默认会new一个对象
42.注：八种数据类型除了float和double其他的数据类型都具有常量池的概念

<字符串>
43.字符串和byte(字节)数组之间的相互转换(常用于字符串和二进制之间的转换)：
String str = "java编程基础";
byte[] arrs = str.getBytes(); // UTF-8中一个汉字占3个字节
for(int i=0;i<arrs.length;i++)
{
System.out.print(arrs[i]+" ");//是一串二进制数字
}
String str1=new String(arrs); //将字节数组转换为字符串
String str2=new String(arrs,"GBK");//带编码的构造函数，如果编译器的编码不是UTF-8则会出现乱码，解决方法就是在第二行改为：byte[] arrs = str.getBytes("GBK");
44.String str="aaa";//此时是在栈中分配一块名为str的内存，等号后是在常量池中分配一块内存存放aaa，等号赋值后，栈中名为str的内存指向常量池中存放aaa的内存
String str2=new String("haha");//此时是在栈中分配一块名为str的内存，等号后是在栈中分配一块内存存放haha，等号赋值后，栈中名为str的内存指向栈中存放haha的内存
45.StringBuilder和String的不同是String不可变，StringBuilder可变，即堆中内存存放的内容可变

<集合>
46.List特点：有序可重复，主要的实现类是ArrayList和LinkedList
47.1.添加 add，插入 add(int index,Object element)插入到index标号后面 , 2.删除 remove 3.显示(注:如果获取的是对象，返回Object类，必要时需要进行强制转换) get(int index), 4.修改 set(int index,Object element)

48.Set特点：无序不可重复，主要的实现类HashSet
49.1.添加 add，2.显示(无get方法) Interator(迭代器)，
例：Iterator it=Set对象.iterator();
while(it.hasNext())
{
System.out.print(it.next());
}3.插入(因为无序，所以没有根据index插入) add，如果插入重复的数据，插入失败但不会报错，注意，如果集合存取的是对象，只要对象地址不同，即使插入对象的数据和集合中存在对象的数据相同，对象也能插入集合中，解决方法：在类中重写hashCode和equals方法，右键点击sources点击带有hashCode和equals的按钮，hashCode方法按默认的，equals方法需要重新编写
例（类为Cat,有String name,int month属性及setter getter方法，在类中重写方法）：
@Override
public boolean equals(Object obj)
{
//判断对象是否相等
if(this==obj)
  return true;
//判断obj是否是Cat类的对象
if(obj.getClass()==Cat.class)
{
  Cat cat=(Cat)obj;
  return cat.getName().equals(name)&&(cat.getMonth()==month);
}
return false;
}4.查找：1.set对象.contains(查找的对象名)，2.根据对象属性查找需要循环遍历查找，5.删除：remove

50.Map特点：主要的实现类HasMap，1.以键值对存储，2.不能包含重复的键值，3.允许使用null值和null键，但只能有一个null键，4.无序排列
51.1.添加 put(key值,value值)，2.删除 remove(key值)，3.get(键值)通过键值获取value值，4.entrySet返回键值对的所有信息，5.keySet取出所有的键值，6.values返回所有的value值
例：
Map<String,String> animal=new HashMap<String,String>();
//添加
if(animal.containsKey("小明"))
System.out.print("key值重复，不能添加");
else
animal.put("小明","是小猫");
if(animal.containsKey("小红"))
System.out.print("key值重复，不能添加");
else
animal.put("小红","是小狗");
//输出所有的value 使用迭代器
Iterator<String> it = animal.values().iterator();
while(it.hasNext())
{
System.out.print(it.next);
}
//输出所有的key和value
Set<Entry<String,String>> entrySet=animal.entrySet();
for(Entry<String,String> entry:entrySet)
{
System.out.print(entry.getKey());
System.out.print(entry.getValue());
}
//根据key值查找
Set<String> keySet=animal.keySet();
for(String key:keySet)
{
if(key.equal("小明"))
{
System.out.print(key+"->"+animal.get(key));
break;
}
}

java基础（类到集合）随记

猜你喜欢