java基础(三)

You got a dream, you gotta protect it. People can’t do something themselves,they wanna tell you you can’t do it.If you want something, go get it.

Day10 object
一、Object
1、概述：
Object是所有类的超类，父类。所有的类都直接或在间接继承自Object。
2、Object类中的常用方法
——equals(Object obj)、toString()、getClass()、hashCode()
A：public boolean equals(Ojbect obj)
**对对象进行比较，该方法默认比较的是对象的地址。而自定义的对象，比较地址没有什么意义。所有呢，我们自定义的对象，一般都会重写此方法，完成自己想要比较的内容。

B：public String toString()
**将对象按照字符串的格式输出。输出格式：对象类型@对象的哈希值
一般来说，这个值对我们没有任何意义。所以我们会重写此方法。建立自己特有的 字符串表示。
C：public final Class <>? getClass()
**获取的是对象的字节码文件 反射
D：public int hashCode()
**返回该对象的哈希码值。(十进制的)
E：protected Object clone()
**创建并返回此对象的一个副本，重写该方法
**cloneable-标记接口，告诉该接口的类可以实现对象的复制。

3、==和equals区别
——————– “==”和equals方法究竟有什么区别？
（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String(“foo”);
String b=new String(“foo”);
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
自学Math类。完成如下作业：
1：给一个圆，把半径做为属性，求圆的面积。要求使用Math类中一些内容。
import java.util.*;
class AreaTest{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double a = sc.nextDouble();
final double B =2;
GetArea ga = new GetArea();
System.out.println(“半径为”+a+”的圆的面积是：”+ga.getArea(a,B));
}
}
class GetArea{
public double getArea(double a,double b){
double s = Math.PI*Math.pow(a,b);
return s;
}
}
二、内部类
1、概述
—–在类的内部定义的类，只不过是类的位置发生了变化而已。
2、特点
A：内部类可以直接访问外部类的成员，包括private修饰的。
内部类都持有一个外部类的引用——-外部类名.this
B：外部类要想访问内部类，必须创建对象。
3、在类中的所在位置
A：成员内部类
class Outer{
private int num = 10;
class Inner(){
void show(){
System.out.println(“show”);
}
}
void method(){
Inner i = new Inner();
i.show();
}
}
外部：访问权限不为private

**它可以被private修饰
class Body{
private class Heart{
//code
}
public Heart getHeart(){
//code
return new Heart();
}
}
**它可以被static修饰,它只能访问外部类中的静态成员
(内部类没有外部类的引用)
如果内部类中定义了静态成员，那么内部类必须定义为静态的。

    B：局部内部类
        class Outer{
            void method(){
                final int X = 10;
                class Inner{
                    void show(){
                        System.out.println(X);
                    }
                }
                Inner i = new Inner();
                i.show();
            }
        }
        **它可以访问外部类的成员，也可以访问局部变量，但是访问局部的变量必须
          被final修饰，其实也就是常量。<不定义为final，此变量会随着方法的结              束而释放，此时，内部类的引用可能还存在(用父类Object进行接收)，此时           无法访问该变量>
        **它不可以被private或者static修饰。

4、匿名内部类
A：没有名字的局部的内部类。
B：前提
**内部类可以继承或实现一个外部类或者接口。
C：格式
**new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
D：简单理解：
**就是建立一个带内容的外部类或者接口的子类匿名对象。
举例：
interface Inter{
public abstract void show();
}
class Outer{
void method(){
//第一种：
new Inter(){
public void show(){
System.out.println(“show”);
}
}.show();
//第二种：调用多个方法的时候可以采用这种
Inter i = new Inter(){
public void show(){
System.out.println(“show”);
}
};
i.show();
}
}
5、什么时候使用匿名内部类?
通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
面试题：自己再分析一次。
interface Inter{
void show();
}
class Outer{
//请补足代码。
static Inter method(){
/*
class Demo implements Inter{
public void show(){
System.out.println(“show”);
}
}
*/
//Inter i = new Demo();
return new Inter(){
public void show(){
System.out.println(“show”);
}
};
}
}
class InnerClassTest{
Outer.method().show();
}
Day11 包 常用修饰符 打jar包 测试题
一、包
1、概念与用途
我们可以将包想象成文件夹
常见用途
A：对类进行管理
B：让类有了多层命名空间 cn.itcast.Demo
C：不同包中类之间的访问
2、import关键字
import用于导入其他包中的类.
使用的格式：
import 包名.类名;———–>单个导入
import 包名.*;—————->多个导入
但是建议使用: 包名.类名;
二、常见修饰符
1、权限修饰符
同一个类中 同一个包中 不同包中的子类中 不同包中
private OK
(default) OK OK
protected OK OK OK
public OK OK OK OK
2、其他修饰符
class 构造方法 成员方法 成员变量
private OK OK OK
(default) OK OK OK OK
protected OK OK OK
public OK OK OK OK
final OK OK OK
static OK OK
abstract OK OK
如果class(构造，成员)它能被多个修饰符修饰，那么这多个之间是可以组合使用。但是得注意特殊情况。如abstract
public static final String S = “Hello”;
public abstract void show();
public final void show2(){}
3、jar包
java中压缩包
方便携带和使用。
set classpath=c:\my\haha.jar;.
4、测试题
 char型变量中能不能存贮一个中文汉字？为什么？
答：char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。(unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。)
 静态变量和实例变量的区别？
(1)作用范围
A：静态变量随着类的加载而加载，随着类的消失而消失。生命周期最长。
B：实例变量随着类的创建而加载，对象消失，实例变量消失。
(2)存储空间
A：静态变量存储在方法区中的静态区，被所有实例共享。
B：实例变量存储在堆内存中，只被某一个对象所特有。
(3)调用方式
A：静态变量既可以通过对象名调用，也可以通过类名直接调用。
B：实例变量只能通过对象名调用。
 abstract class和interface有什么区别？
答: A：抽象类只能单继承,接口可以多实现。
B：抽象类中可以有非抽象方法,抽象类中可以定义变量和常量。接口中的方法都是抽象的。接口中只能有静态常量。接口中的方法都有默认修饰符：public abstract接口中的成员变量都有默认修饰符：public static final
C：抽象类中定义的是一个体系的共性功能,接口中通常定义的对象中的扩展功能。
D：接口的出出现避免了单继承的局限性。
E：抽象类被继承表示的是：is a 的关系。叫做：xx是yy的一种。接口被实现表示的是：like a 的关系。叫做：xx像yy一种。
 面向对象的特性有哪些，分别阐述说明？
(1)抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程(行为)抽象，二是数据(属性)抽象。
(2)继承：继承是一种层次模型，允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
(3)封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
(4)多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性(重载)和对象多态性(子父类的重写)。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序方法同名问题。
Day12 String StringBuffer StringBuilder 封装类
一、String类常见方法的使用
字符串数据都是一个对象
字符串数据一旦初始化就不可以被改变了
字符串对象都存储于常量池中，字符串常量池。
String str1 = “abc”;
String str2 = “abc”;
String str3 = new String(“abc”);
为什么str1==str2结果为true呢？
先会在内存里创建str1以及其指向的内容”abc”,当再次创建str2时，会在常量池里找是否有”abc”，
有就不会再开辟内存空间，str2直接指向已有的”abc”,也就是str2和str1指向了同一个对象。
为什么str1==str3结果为false呢？
==比较的地址值，而new是重新开辟的。
为什么str1.equals(str3)结果为true呢？
String类复写了Object类的equals方法，比较的是字符串中的内容是否相同。
1、判断
A：equals(Object obj)字符串类重写了Object的方法,用于比较字符串的值是否相等。
equalsIgnoreCase(String anotherString)用于比较字符串的值是否相等.不区分大小写
B：contains(String s)判断一个字符串中是否包含另一个字符串
C：startsWith(String prefix)测试此字符串是否以指定的前缀开始。 startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
endsWith(String suffix)测试此字符串是否以指定的后缀结束。
D：isEmpty()判断字符串是否为空
2、获取
A：int length()获取字符串的长度
B：char charAt(int index)获取指定位置的字符
C：获取指定的字符或者字符串在给定的字符串中第一次出现的索引
int indexOf(int ch)获取指定字符在字符中第一次出现的索引
int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。
int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
D：获取指定的字符或者字符串在给定的字符串中最后一次出现的索引
int lastIndexOf(int ch)返回指定字符在此字符串中最后一次出现处的索引。
int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
E：获取子串
String substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个 子字符串。 <含头不含尾>
3、转换
A：字符串和字节数组的转换
从String到byte[]——>byte[] getBytes()
从byte[]到String——–>new String(byte[] by)构造方法
B：字符串和字符数组的转换
从String到char[]
***char[] toCharArray()
***length(),charAt(int index)结合
从char[]到String
***new String(char[] ch)
***static copyValueOf(char[] data)
***static String valueOf(char[] data, int offset, int count)
D：static String valueOf(Object obj) 把对象转成字符串
E：String toUpperCase() 所有字符都转换为大写
String toLowerCase() 所有字符都转换为小写
F：字符串的连接
字符串连接符：+
String concat(String str) 将指定字符串连接到此字符串的结尾。
String s = “aaa” s.concat(“bbb”).concat(“ccc”).concat(“ddd”);
4、替换
String replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(String oldString, String newString)返回一个新的字符串，它是通过用 newString 替换此字符串中出现的所有 oldString 得到的。
5、切割
String[] split(String regex)根据给定的字符串把字符串分割.
6、去除字符串的空格
trim() 去除字符串的前后空格

三、StringBuffer&StringBuilder
1、字符串String是定长的，StringBuffer是变长的.
String s = “Hello”;
s = s + “World”; //”HelloWorld”

StringBuffer buffer = new StringBuffer("Hello");
buffer.append("World"); 

构造方法：
Public StringBuffer();无参构造
Public StringBuffer(int capacity);指定容量
Public StringBuffer(String s);指定字符串内容
2、append(元素)追加
insert(int n,String str) 在指定位置插入
reverse();反转
int capacity();容量 它可以存储的元素个数
int length();长度 它实际存储的元素个数
Stringbuffer deleteCharAt(int index)删除指定位置字符，并返回自身
Stringbuffer deleteCharAt(int start,int end)删除指定位置开始结束字符，并返回自身（包左不包右）
Stringbuffer replace(int start,int end ,String str) 替换指定位置
String substring(索引,);
把StringBuffer中的一部分复制,然后把复制的这部分内容赋给了一个String.
StringBuffer 转为 String:
String str = new String(Stringbuffer);
String str = buffer.toString();
3、StringBuffer,StringBuilder区别
StringBuffer 线程安全的,效率低(同步)
StringBuilder 线程不安全的,效率高(不同步)
四、封装类
基本数据类型和引用类型之间能转换吗?不能
int x = 20;
String s = x;
“10-20” 我们可以使用split方法进行切割,切割后生成了一个字符串数组 String[] strArray = {“10”,”20”}
int startAge = strArray[0];
int endAge = strArray[1];
为了使我们的基本数据类型和字符串能够相互转换(字符串必须是能够转换的):
我们就对基本数据类型进行了封装，使每一个基本数据类型都有一个对应的封装类，这个时候，我们就可以使用封装类中的方法进行转换.
byte Byte
Short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
1、基本类型到封装类的转换
JDK1.5以后的新特性
Integer i = new Integer(5)
Integer ii = 5; //装箱 Integer i = new Integer(int)
Integer iii = ii + 20; //先把ii拆箱变成一个int类型的数据,然后在和20做加法,
//最后在把结果装箱成一个Integer类型的数据.
ii.intValue();
2、基本类型到字符串的转换
String toString(); Integer类型
static String toString(int x);
3、字符串到基本类型的转换
static int parseInt(String s)
int startAge = Integer.parseInt(strArray[0]);
int endAge = Integer.parseInt(strArray[1]);
static Integer valueOf(String s)
他们都实现了Comparable接口，具备了compareTo方法，用于比较，结果只有整数、零和负数。
基本数据类型用比较运算符进行比较，引用数据类型用compareTo进行比较。

Day13 工具类
一、Arrays工具类
A:Public static String toString(int[] a)
数组转换为字符串
B：Public static void sort(int[] a)
数组进行排序
C：Public static int binarySearch(int[] a,int key)
二分查找
Int类型转为String: String.valueof(number)
String类型转为Int: Integer.pareInt(s)

十进制到其他进制
Public static String toString(int I,int radix)
其他进制到十进制
Integer.pareInt(int I,int radix)

二、Character
A:Public static boolean isUpperCase(char ch)
判断大写
B:Public static boolean isLowerCase(char ch)
判断小写
C:Public static boolean isDigit(char ch)
判断数字
D:Public static char toUpperCase(char ch)
转为大写
E:Public static char toLowerCase(char ch)
转为小写

三、Math
A:Public static int abs(int a)
绝对值
B:Public static double ceil(double a)
向上取整
C: Public static double floor(double a)
向下取整
D: Public static int max(int a,int b)
两个数据中的大值
E: Public static double pow(double a,double b)
a的b次幂
F: Public static double random(double a)
随机数[0.0,1.0)
G: Public static int round(double a)
四舍五入
H: Public static double sqrt(double a)
正平方根
四、System
(1)系统类,提供了一些有用的字段和方法
(2)成员方法(自己补齐)
A:运行垃圾回收器
Public static void gc();
B:退出jvm
Public static void exit(int status)
C:获取当前时间的毫秒值
Public static long currentTimeMills()
D:数组复制原数组，从指定位置开始，到目标数组指定位置结束
Public static void arraycody(object src,int srcPos,Object dest,int destpos ,int length)
五、BigDecima
(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
(2)构造方法
A:BigDecimal(String s)
(3)成员方法：
A:加 add
B:减 sbutract
C:乘 multiply
D:除 divide
E:返回商和余数的数组
Public BigInteger[] divideAndeRemainder（BigInteger val）
六、Date/DateFormat
(1)Date是日期类，可以精确到毫秒。
A:构造方法
Date() 当前毫秒值
Date(long time) 给定毫秒值 1970年1月1日开始
B:成员方法
getTime()
setTime(long time)
C:日期和毫秒值的相互转换
案例：你来到这个世界多少天了?
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
A:SimpleDateFormat(String pattern) 给定模式
yyyy-MM-dd HH:mm:ss
B:日期和字符串的转换
a:Date – String
format()

        b:String -- Date
            parse()

五、Calendar
(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance();
本质返回的是子类对象
(3)成员方法
A:根据日历字段得到对应的值
get(Calendar.XXX)
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
Public void add(int field,int mount)
C:设置日历对象的年月日
setTime(Date d)
Public final void set(int year,int month,int date)
(4)案例：
计算任意一年的2月份有多少天?