Java 对象
2015-08-16 21:04
429 查看
1一个文件中最多只能有一个public的class声明，其它类型的个数不限。
2 一个原文件中有n个类，编译的class文件就有n个。
3 return的作用
1） 返回值 2）结束函数
4 方法重载
1）同一个类中
2）方法名相同
3）参数列表不同（个数、顺序、引入类型）
5 为什么要引入方法重载
1）方便阅读 因为方法名相同（功能类似）
2）优化了程序的设计 可以在原来方法的基础上扩展功能
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 面向过程与面向对象的区别
面向过程：只有怎么做 ，没有谁去做。直接与cpu交流，模拟操控cpu的过程，进行数据的数据和处理。
面向对象： 对象作为接受信息的单位，不同的对象处理和存储不同的数据，对象之间协同完成功能。
2 new: 开辟了堆内存的一块空间，用于存放对象。
3 无法从静态方法中调用非静态方法。
4 封装定义
就是将一类事物的属性和方法包装到一个单元中，隐藏了属性和功能，对外提供公共的访问方式。
------>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 this关键字
每个类的每个非静态方法都会隐含一个this，它指向调用这个方法的对象
用法： 1）区分成员变量和局部变量。
2）调用本类中的其它构造方法。this(参数1，参数2，参数3.....)>>>>>>>>>必须放在第一行
2 构造代码块（对 对象进行初始化）
对象被创建时，执行一次。执行顺序再super()之后
class Person{
{
System.out.print("这是构造代码块");
}
person(){
super();
//执行构造代码块
}
3 static
1) 静态变量被所有对象共享
2） 静态随着类的加载而加载，随着类的消失而消失
3） 内存的分配优先于对象而存在
4） 静态成员可以直接被类所调用。
4 当类中所有的变量和方法都为static时，一般为工具类，这时候不希望被创建对象，那么就可以将构造函数私有化。
5 静态方法只能个调用静态成员，不能调用非静态成员。非静态方法可以调用静态的，也能调用非静态的。
原因：
静态的优先于对象，静态方法执行时，还没有对象，就没法使用非静态的变量、方法。
6 在静态方法中不允许出现 this,super（this、super都依附于对象）
原因 this是代表的当前对象，而静态方法执行时还没有对象。
7 非静态成员变量又叫做实例变量，静态成员变量又叫做类变量。（还有局部变量）
8 非静态变量随着对象的存在而存在，消失而消失；静态变量随着类的存在而存在，消失而消失。
9 非静态成员变量存在堆内存中，静态呢的存在方法区中的数据共享区。
10 静态代码块（对类进行初始化）
1）随着类的加载而运行，而且只运行一次。
2）优先于主函数。
static{
}
11 什么时候用static
1)当不同的对象调用方法都没有影响时。
2) 所有对象对该属性的值都一样时。
12static变量，当其中一个对象将值改变后，其它对象的值也改变（数据共享）
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 继承的好处（单继承）
1）提高了代码的复用性
2）让类和类之间有了关系
2 java单继承原因
防止对象的调用的不确定性。
3 super(代表了父类所属的空间)
用于访问父类中定义的属性和成员方法。
5 访问权限
private :只能本类使用
default 同一个包中所有类 (默认)
proteced 同一个包中所有类 不同包中的子类
public 所有
6创建子类对象时，默认都会先通过super()访问父类的无参构造函数。、
7 this()和super()调用构造方法，必须放在第一行（进行初始化 的工作）,super()-----》调用父类的构造方法
8 覆写
1 返回值 方法名 参数 都相同
2 权限修饰符的范围不能比被覆写方法的小
9 静态方法被覆写也必须时静态
10 重写（Overriding）与重载（Overloading）的区别
1）重写是在子类中，重载是在同一个类中。
2）重写要求方法要和父类的方法返回值 方法名 参数完全一样； 重载要求方法名相同 参数不同，与返回值没有关系。
3） 重写要求访问权限的范围不能比父类的小；重载对访问权限没有要求。
11 this和super的区别
】 访问属性和方法的时候，this先在子类中查找，子类中没有，就在父类中查找；而super直接查找父类。
】this调用本类中其它的构造方法；而super调用父类中的构造方法。
】this可以代表一个当前对象并且可以作为参数；而super没有这些概念。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 final常和static连用
final定义的是常量，值不会随着对象的改变而改变。这时候就可以用static进行修饰，把变量放到内存中的数据共享区。
2 对象在内存中初始化的过程
】将对象所需要的类文件加载进入内存
】然后再堆内存中开辟一片空间
】对对性属性进行一个默认的初始化
】再调用对应的构造函数
】先看构造函数中对应的父类的构造
】把负累的属性读取进入对象的堆空间
】构造函数自定义的部分进行初始
3 抽象类（abstract）
】 只有方法的声明，没有方法体
】抽象方法所在的类就是抽象类
】abstract只能修饰类和变量
】抽象类不能被实例化，只能被继承，子类必须重写所有的抽象方法，否则这个子类还是抽象类
】抽象类有构造函数（进行子类的初始化）
】抽象类可以有非抽象方法
4 抽象类修饰符abstract不能和哪些关键字一起使用
】final:一个继承，一个不继承，矛盾
】private: 私有的不能被访问而抽象方法要被事项，矛盾。
】static:静态的可以直接用类调用方法，而抽象方法没有具体实现，调用是没有意义的。
5 接口的特点（interface）
】属性默认修饰符 public static final(所以属性都是常量)
】方法都是抽象方法（默认修饰符 public abstract）
】不能被实例化
】接口之间可以多继承
】降低了耦合性，提高了扩展性，制订了统一标准
6 抽象类和接口的区别
】 抽象类是继承的行为；接口是制定了规则。
】 一个是继承；一个是实现
】抽象类是单继承，接口是多继承
】抽象类中可以有非抽象方法，接口中都是抽象方法
7 Object中常用类
】equals(Object o)判断两个对象是否相等
】 hasCode() 返回该对象的哈戏码值
】 getClass() 返回对象所属的类
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 多态
】方法的多态（重载、重写）
】 对象的多态（Animal类可以有Cat类、Dog类等）,表现在向上转型，向下转型。
】提高了程序的可扩展性
2 向上转型
】Animal a=new Cat();
】不能使用子类特有的方法；
】调用的成员变量是父类中的
】如果子类重写了方法，则调用的方法是子类中的。（如果是静态的方法，则调用的是父类的）
】什么时候用：当程序需要扩展的时候或者限定了对对象方法进行操作的时候的方法。
3 向下转型
Animal a=new Cat();
Cat b=(Cat)a;
好处 能够调用子类特有的功能
弊端 容易类型转换错误
Animal a=new Cat();
Dog d=(Dog)a;-->类型转换异常
】什么时候用： 调用子类特有的功能的时候。
4 非法转型
Animal a=new Animal();
Dog d=(Dog)a;
5 内部类可以直接访问外部类的成员（持有外部类的引用 类名.this），外部类要通过对象访问内部类的成员。
6 如果内部类中有静态成员，那么这个类也必须被static修饰。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 声明数组时不能指明长度 int a[3];(x)
2 数组再占内存中指向堆内存中第一个元素的地址。
3 增强型 for循环（把遍历的步骤交给编译器）
for (Type element:array){
System.out.print(element);
}--再遍历的过程中，把array中的元素给了element
局限性：不能对具体的元素进行操作（没有下标）
4 选择排序（面试题）
第一个值分别和后面数值进行比较，把较小的那个放在第一个位置，以此类推。
5 冒泡排序（面试题）
第一个和第二个比，把较大的给第二个，第二个与第三个比，把较大的给第三个。。。。以此类推，把最大的给最后一个。
例子：int a[]={1,2,3,4,5,6};
a[0]-a[1] a[1]-a[2] a[2]-a[3] a[3]-a[4] a[4]-a[5]
a[0]-a[1] a[1]-a[2] a[2]-a[3] a[3]-a[4]
a[0]-a[1] a[1]-a[2] a[2]-a[3]
a[0]-a[1] a[1]-a[2]
a[0]-a[1]
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j]<a[j+1]){
int n=a[j];
a[j]=a[j+1];
a[j+1]=a[j];
}
}
}
6 int a[]={1,2};
in b[]=a;
b[0]=3;
则 a[0]=3，int b[]=a是把数组a指向的地址给了数组b
7 二分法查找（面试）-->前提是排序好的
】定义一个最小坐标的变量和一个最大坐标的变量
】定义一个中间值的坐标
】查找前提：最小的坐标小于最大的坐标
】中间点为（起点+终点）/2
】判断中点的值和需要找的数据的关系，大则在中点的右边，小则在左边，等于则返回
】查找结束后没有找到元素返回-1。
int low=0;
int high=arr.length;
int mid=0;
while(low<=high){
mid=(high)
if(key>arr[mid]){
low=mid+1;
}else if(key==arr[mid]){
return mid;
}else{
high=mid;
}
return -1;
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 二维数组(int [] f []可以这样写)
Java并没有真正的多维数组，二维数组可以看成以数组为元素的数组
int [][]b=new int[3][];
b[0]=new int[2];
b[1]=new int[3];
b[2]=new int[5];
2 throws（抛类）
抛出异常，表明该方法不处理异常，而是交给方法的调用处进行处理。throw抛出的是一个自定义异常的对象。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 String 是不可变的字符串
原因 ：源码 public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
】 private final char value[];
String 再底层就是对char类型数组的操作，定义成final类型的，所以不可变。
2 String s1="abc" String s2="abc";
s1==s2 返回true(没有new对象 s1 s2直接指向"abc"所在的常量池地址)
】String s1=new String("abc");
String s2=new String ("abc");
s1==s2 返回值为false(s1 与 s2指向不同的地址)
3 StringBuilder StringBuffer
】StringBuilder可变的字符序列，线程不安全，但在单线程中的效率比StringBuff高
】StringBuffer 可变的字符序列，线程安全，效率低。
】两者内部封装的代码可进行自动的扩容
】通过append()方法形成方法链的原因是返回他本身的对象。
public synchronized StringBuffer append(boolean b) {
super.append(b);
return this;
}
public StringBuilder append(boolean b) {
super.append(b);
return this;
}
】
工作原理是：预先申请一块内存，存放字符序列，如果内存满了，会重新改变缓存区的大小，以容纳更多的字符序列。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1一个文件中最多只能有一个public的class声明，其它类型的个数不限。
2 一个原文件中有n个类，编译的class文件就有n个。
3 return的作用
1） 返回值 2）结束函数
4 方法重载
1）同一个类中
2）方法名相同
3）参数列表不同（个数、顺序、引入类型）
5 为什么要引入方法重载
1）方便阅读 因为方法名相同（功能类似）
2）优化了程序的设计 可以在原来方法的基础上扩展功能
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 面向过程与面向对象的区别
面向过程：只有怎么做 ，没有谁去做。直接与cpu交流，模拟操控cpu的过程，进行数据的数据和处理。
面向对象： 对象作为接受信息的单位，不同的对象处理和存储不同的数据，对象之间协同完成功能。
2 new: 开辟了堆内存的一块空间，用于存放对象。
3 无法从静态方法中调用非静态方法。
4 封装定义
就是将一类事物的属性和方法包装到一个单元中，隐藏了属性和功能，对外提供公共的访问方式。
------>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 this关键字
每个类的每个非静态方法都会隐含一个this，它指向调用这个方法的对象
用法： 1）区分成员变量和局部变量。
2）调用本类中的其它构造方法。this(参数1，参数2，参数3.....)>>>>>>>>>必须放在第一行
2 构造代码块（对 对象进行初始化）
对象被创建时，执行一次。执行顺序再super()之后
class Person{
{
System.out.print("这是构造代码块");
}
person(){
super();
//执行构造代码块
}
3 static
1) 静态变量被所有对象共享
2） 静态随着类的加载而加载，随着类的消失而消失
3） 内存的分配优先于对象而存在
4） 静态成员可以直接被类所调用。
4 当类中所有的变量和方法都为static时，一般为工具类，这时候不希望被创建对象，那么就可以将构造函数私有化。
5 静态方法只能个调用静态成员，不能调用非静态成员。非静态方法可以调用静态的，也能调用非静态的。
原因：
静态的优先于对象，静态方法执行时，还没有对象，就没法使用非静态的变量、方法。
6 在静态方法中不允许出现 this,super（this、super都依附于对象）
原因 this是代表的当前对象，而静态方法执行时还没有对象。
7 非静态成员变量又叫做实例变量，静态成员变量又叫做类变量。（还有局部变量）
8 非静态变量随着对象的存在而存在，消失而消失；静态变量随着类的存在而存在，消失而消失。
9 非静态成员变量存在堆内存中，静态呢的存在方法区中的数据共享区。
10 静态代码块（对类进行初始化）
1）随着类的加载而运行，而且只运行一次。
2）优先于主函数。
static{
}
11 什么时候用static
1)当不同的对象调用方法都没有影响时。
2) 所有对象对该属性的值都一样时。
12static变量，当其中一个对象将值改变后，其它对象的值也改变（数据共享）
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 继承的好处（单继承）
1）提高了代码的复用性
2）让类和类之间有了关系
2 java单继承原因
防止对象的调用的不确定性。
3 super(代表了父类所属的空间)
用于访问父类中定义的属性和成员方法。
5 访问权限
private :只能本类使用
default 同一个包中所有类 (默认)
proteced 同一个包中所有类 不同包中的子类
public 所有
6创建子类对象时，默认都会先通过super()访问父类的无参构造函数。、
7 this()和super()调用构造方法，必须放在第一行（进行初始化 的工作）,super()-----》调用父类的构造方法
8 覆写
1 返回值 方法名 参数 都相同
2 权限修饰符的范围不能比被覆写方法的小
9 静态方法被覆写也必须时静态
10 重写（Overriding）与重载（Overloading）的区别
1）重写是在子类中，重载是在同一个类中。
2）重写要求方法要和父类的方法返回值 方法名 参数完全一样； 重载要求方法名相同 参数不同，与返回值没有关系。
3） 重写要求访问权限的范围不能比父类的小；重载对访问权限没有要求。
11 this和super的区别
】 访问属性和方法的时候，this先在子类中查找，子类中没有，就在父类中查找；而super直接查找父类。
】this调用本类中其它的构造方法；而super调用父类中的构造方法。
】this可以代表一个当前对象并且可以作为参数；而super没有这些概念。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 final常和static连用
final定义的是常量，值不会随着对象的改变而改变。这时候就可以用static进行修饰，把变量放到内存中的数据共享区。
2 对象在内存中初始化的过程
】将对象所需要的类文件加载进入内存
】然后再堆内存中开辟一片空间
】对对性属性进行一个默认的初始化
】再调用对应的构造函数
】先看构造函数中对应的父类的构造
】把负累的属性读取进入对象的堆空间
】构造函数自定义的部分进行初始
3 抽象类（abstract）
】 只有方法的声明，没有方法体
】抽象方法所在的类就是抽象类
】abstract只能修饰类和变量
】抽象类不能被实例化，只能被继承，子类必须重写所有的抽象方法，否则这个子类还是抽象类
】抽象类有构造函数（进行子类的初始化）
】抽象类可以有非抽象方法
4 抽象类修饰符abstract不能和哪些关键字一起使用
】final:一个继承，一个不继承，矛盾
】private: 私有的不能被访问而抽象方法要被事项，矛盾。
】static:静态的可以直接用类调用方法，而抽象方法没有具体实现，调用是没有意义的。
5 接口的特点（interface）
】属性默认修饰符 public static final(所以属性都是常量)
】方法都是抽象方法（默认修饰符 public abstract）
】不能被实例化
】接口之间可以多继承
】降低了耦合性，提高了扩展性，制订了统一标准
6 抽象类和接口的区别
】 抽象类是继承的行为；接口是制定了规则。
】 一个是继承；一个是实现
】抽象类是单继承，接口是多继承
】抽象类中可以有非抽象方法，接口中都是抽象方法
7 Object中常用类
】equals(Object o)判断两个对象是否相等
】 hasCode() 返回该对象的哈戏码值
】 getClass() 返回对象所属的类
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 多态
】方法的多态（重载、重写）
】 对象的多态（Animal类可以有Cat类、Dog类等）,表现在向上转型，向下转型。
】提高了程序的可扩展性
2 向上转型
】Animal a=new Cat();
】不能使用子类特有的方法；
】调用的成员变量是父类中的
】如果子类重写了方法，则调用的方法是子类中的。（如果是静态的方法，则调用的是父类的）
】什么时候用：当程序需要扩展的时候或者限定了对对象方法进行操作的时候的方法。
3 向下转型
Animal a=new Cat();
Cat b=(Cat)a;
好处 能够调用子类特有的功能
弊端 容易类型转换错误
Animal a=new Cat();
Dog d=(Dog)a;-->类型转换异常
】什么时候用： 调用子类特有的功能的时候。
4 非法转型
Animal a=new Animal();
Dog d=(Dog)a;
5 内部类可以直接访问外部类的成员（持有外部类的引用 类名.this），外部类要通过对象访问内部类的成员。
6 如果内部类中有静态成员，那么这个类也必须被static修饰。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 声明数组时不能指明长度 int a[3];(x)
2 数组再占内存中指向堆内存中第一个元素的地址。
3 增强型 for循环（把遍历的步骤交给编译器）
for (Type element:array){
System.out.print(element);
}--再遍历的过程中，把array中的元素给了element
局限性：不能对具体的元素进行操作（没有下标）
4 选择排序（面试题）
第一个值分别和后面数值进行比较，把较小的那个放在第一个位置，以此类推。
5 冒泡排序（面试题）
第一个和第二个比，把较大的给第二个，第二个与第三个比，把较大的给第三个。。。。以此类推，把最大的给最后一个。
例子：int a[]={1,2,3,4,5,6};
a[0]-a[1] a[1]-a[2] a[2]-a[3] a[3]-a[4] a[4]-a[5]
a[0]-a[1] a[1]-a[2] a[2]-a[3] a[3]-a[4]
a[0]-a[1] a[1]-a[2] a[2]-a[3]
a[0]-a[1] a[1]-a[2]
a[0]-a[1]
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j]<a[j+1]){
int n=a[j];
a[j]=a[j+1];
a[j+1]=a[j];
}
}
}
6 int a[]={1,2};
in b[]=a;
b[0]=3;
则 a[0]=3，int b[]=a是把数组a指向的地址给了数组b
7 二分法查找（面试）-->前提是排序好的
】定义一个最小坐标的变量和一个最大坐标的变量
】定义一个中间值的坐标
】查找前提：最小的坐标小于最大的坐标
】中间点为（起点+终点）/2
】判断中点的值和需要找的数据的关系，大则在中点的右边，小则在左边，等于则返回
】查找结束后没有找到元素返回-1。
int low=0;
int high=arr.length;
int mid=0;
while(low<=high){
mid=(high)
if(key>arr[mid]){
low=mid+1;
}else if(key==arr[mid]){
return mid;
}else{
high=mid;
}
return -1;
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 二维数组(int [] f []可以这样写)
Java并没有真正的多维数组，二维数组可以看成以数组为元素的数组
int [][]b=new int[3][];
b[0]=new int[2];
b[1]=new int[3];
b[2]=new int[5];
2 throws（抛类）
抛出异常，表明该方法不处理异常，而是交给方法的调用处进行处理。throw抛出的是一个自定义异常的对象。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 String 是不可变的字符串
原因 ：源码 public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
】 private final char value[];
String 再底层就是对char类型数组的操作，定义成final类型的，所以不可变。
2 String s1="abc" String s2="abc";
s1==s2 返回true(没有new对象 s1 s2直接指向"abc"所在的常量池地址)
】String s1=new String("abc");
String s2=new String ("abc");
s1==s2 返回值为false(s1 与 s2指向不同的地址)
3 StringBuilder StringBuffer
】StringBuilder可变的字符序列，线程不安全，但在单线程中的效率比StringBuff高
】StringBuffer 可变的字符序列，线程安全，效率低。
】两者内部封装的代码可进行自动的扩容
】通过append()方法形成方法链的原因是返回他本身的对象。
public synchronized StringBuffer append(boolean b) {
super.append(b);
return this;
}
public StringBuilder append(boolean b) {
super.append(b);
return this;
}
】
工作原理是：预先申请一块内存，存放字符序列，如果内存满了，会重新改变缓存区的大小，以容纳更多的字符序列。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Java多重循环算法问题：（九九乘法表、打印平行四边形、打印空心菱形、打印菱形、搬砖问题、斐波那契数列、猴子吃桃问题、回文数、1！+2！+...+20!）
- 自定义spring schema简化与canal集成
- JavaEE SSH集成框架(两) struts2 本地加载dtd文件，action组态
- java中IO流学习小结
- java 基础（环境变量、）
- JAVA IO操作关键点
- Java类的生命周期详解
- Spring用法快速入门
- Java:多重循环for、while、do-while（简单判断是否是四位整数、1-100累加，水仙花、最大公约数。最小公倍数、完数、输入任意数计算每位数之和、弹力球问题）
- Java内存分配全面浅析
- eclipse中的dynamic web project与Static Web Project 的区别
- Java中循环问题：for,while,do-while 各种练习（打印上三角、下三角、输出100以内的素数、水仙花、最大公约、最小公倍数、分解质因数、兔子问题）
- 浅析Spring事务传播行为和隔离级别
- Spring配置简化
- struts2学习笔记（十三）文件下载
- 深入理解java的static关键字
- java中堆与栈的区别
- hdu 1131 Count the Trees Java 大数
- 初学Java，粗浅看待数据类型与运算符中需要注意的问题
- JAVA 的checked异常 和 unchecked异常