------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------
1： 定义类：
java里定义类的简单语法是：
【修饰符】 class 类名 {
}
2: 成员变量和局部变量的区别
成员变量：
成员变量定义在类中，在整个类中都可以被访问。
成员变量随着对象的建立而建立，存在于对象所在的堆内 存中。
成员变量有默认初始化值。
局部变量：
3： 匿名对象局部变量只定义在局部范围内，如：函数内，语句内等。
局部变量存在于栈内存中。
作用的范围结束，变量空间会自动释放。
局部变量没有默认初始化值。
匿名对象是对象的简化形式
匿名对象两种使用情况
当对对象方法仅进行一次调用的时
匿名对象可以作为实际参数进行传递
4：封装
封装：是指隐藏对象的属性和实现细节，仅对外提供 公共访问方式。
好处：
•将变化隔离。
•便于使用。
•提高重用性。
•提高安全性。
封装原则：
•将不需要对外提供的内容都隐藏起来。
•把属性都隐藏，提供公共方法对其访问。
5： 构造函数
特点：
1.函数名与类名相同
2.不用定义返回值类型
3.不可以写return语句
作用：
给对象进行初始化。
注意：
1.默认构造函数的特点。
2.多个构造函数是以重载的形式存在的。
6： static(静态)关键字
1:用于修饰成员（成员变量和成员函数）
2:被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用
3:使用注意
静态方法只能访问静态成员
静态方法中不可以写this，super关键字
4: 静态的使用：主函数是静态的
public class ArrayTool { private ArrayTool(){} /** 最大值。 */ public static int getMax(int[] arr) { int max = 0; for(int x=1; x<arr.length; x++) { if(arr[x]>arr[max]) max = x; } return arr[max]; } /** 最小值。 */ public static int getMin(int[] arr) { int min = 0; for(int x=1; x<arr.length; x++) { if(arr[x]<arr[min]) min = x; } return arr[min]; } /** 选择排序 */ public static void selectSort(int[] arr) { for (int x=0; x<arr.length-1 ; x++ ) { for(int y=x+1; y<arr.length; y++) { if(arr[x]>arr[y]) { swap(arr,x,y); } } } } /** 冒泡排序 */ public static void bubbleSort(int[] arr) { for (int x=0; x<arr.length-1 ; x++ ) { for(int y=0; y<arr.length-x-1; y++) { if(arr[y]>arr[y+1]) { swap(arr,y,y+1); } } } } private static void swap(int[] arr,int a,int b) { int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } public static void printArray(int[] arr) { System.out.print("["); for(int x=0; x<arr.length; x++) { if(x!=arr.length-1) System.out.print(arr[x]+", "); else System.out.println(arr[x]+"]"); } } }
7: 继承的特点
1:Java只支持单继承，不支持多继承。
•一个类只能有一个父类，不可以有多个父类。
•class SubDemo extends Demo{} //ok
•class SubDemo extends Demo1,Demo2...//error
2:Java支持多层继承(继承体系)
•class A{}
•class B extends A{}
•class C extends B{}
3:定义继承需要注意：
•不要仅为了获取其他类中某个功能而去继承
•类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
8: super关键字
1;super和this的用法相同
2:this代表本类应用
3:super代表父类引用
4:当子父类出现同名成员时，可以用super进行区分
5:子类要调用父类构造函数时，可以使用super语 句。
9: 函数覆盖(Override)
1: 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。
2:父类中的私有方法不可以被覆盖。
3:在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名 获取。
4:覆盖注意事项：
•覆盖时，子类方法权限一定要大于等于父类方法权限
•静态只能覆盖静态。
5:覆盖的应用：
•当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写 父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内 容。
10:子类的实例化过程
1:子类中所有的构造函数默认都会访问父类中空参数的 构造函数
2:因为每一个构造函数的第一行都有一条默认的语句 super();
3:子类会具备父类中的数据，所以要先明确父类是如何 对这些数据初始化的。
4:当父类中没有空参数的构造函数时，子类的构造函数 必须通过this或者super语句指定要访问的构造函数。
11:final关键字
1：final可以修饰类，方法，变量。
2：final修饰的类不可以被继承。
3：final修饰的方法不可以被覆盖。
4：final修饰的变量是一个常量。只能被赋值一次.
5: 内部类只能访问被final修饰的局部变量。
例如：///void show1(){} 不能被打开
class Demo { final int x = 3; public static final double PI = 3.14; final void show1() {} void show2() { final int y = 4; System.out.println(3.14); } } class SubDemo extends Demo { //void show1(){} }
12: 抽象类的特点
1:抽象类和抽象方法必须用abstract关键字来修饰。
2:抽象方法只有方法声明，没有方法体，定义在抽象类中。
•格式：修饰符abstract 返回值类型 函数名(参数列表) ;
3:抽象类不可以被实例化，也就是不可以用new创建对象。原因如 下：
•抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实 例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
•而且抽象类即使创建了对象，调用抽象方法也没有意义。
4:抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象 方法后才可以创建对象，否则该子类也是抽象类。
5: 特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
注意：abstract final 不能同时使用，因为abstract 需要被子类重写 final 规定不能被重写。所以冲突
abstract class Student { abstract final void study(); //abstract void study1(); void sleep() { System.out.println("躺着"); } }
13: 接口
1:格式：
interface {}
2:接口中的成员修饰符是固定的。
•成员常量：public static final
•成员函数：public abstract
3:接口的出现将“多继承”通过另一种形式体现出 来，即“多实现”。
4: 例如：
abstract class Student { abstract void study(); void sleep() { System.out.println("sleep"); } } interface Smoking { void smoke(); } class ZhangSan extends Student implements Smoking { void study(){} public void smoke(){} }
5： 抽象类和接口的异同：
相同：
1，都可以在内部定义抽象方法。
2，通常都在顶层。
3，都不可以实例化，都需要子类来实现。
不同点：
1，抽象类中可以定义抽象方法和非抽象方法，
而接口中只能定义抽象方法。
2，接口的出现可以多实现。
抽象类只能单继承。
也就是说：接口的出现避免了单继承的局限性。
3，继承和实现的关系不一致。继承：is a，实现：like a
14: 多态
1:体现：
父类或者接口的引用指向或者接收自己的子类对象。
2:作用：
多态的存在提高了程序的扩展性和后期可维护性
3:前提：
•需要存在继承或者实现关系
•要有覆盖操作
4:特点
成员函数：
•编译时：要查看引用变量所属的类中是否有所 调用的成员。
•在运行时：要查看对象所属的类中是否有所调 用的成员。
成员变量：
•只看引用变量所属的类。
5: 例子：
class Cat extends Animal { public void eat() { System.out.println("吃鱼"); } public void catchMouse() { System.out.println("抓老鼠"); } } class Dog extends Animal { public void eat() { System.out.println("吃骨头"); } public void kanJia() { System.out.println("看家"); } } class Pig extends Animal { public void eat() { System.out.println("饲料"); } public void gongDi() { System.out.println("拱地"); } } class JiuJiu { public static void main(String[] args) { function(new Dog()); function(new Cat()); } public static void function(Animal a) { a.eat(); if(a instanceof Cat) { Cat c = (Cat)a; c.catchMouse(); } else if(a instanceof Dog) { Dog c = (Dog)a; c.kanJia(); } }}
15:内部类
将一个类定义在另一个类的里面，对里面那个 类就称为内部类（内置类，嵌套类）。
访问特点：
•内部类可以直接访问外部类中的成员，包括私有成 员。
内部类的位置•而外部类要访问内部类中的成员必须要建立内部类 的对象。
内部类定义在成员位置上
•可以被private static成员修饰符修饰。
•被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
•也可以直接访问外部类中的成员。
注意：当内部类中定义了静态成员，该内部类必须是static的。例子：•同时可以访问所在局部中的局部变量，但必须是被final修 饰的。
class Outer { private int x = 3; class Inner//内部类 { void function() { System.out.println("innner :"+Outer.this.x); } } /**/ void method() { Inner in = new Inner(); in.function(); } } class InnerClassDemo { public static void main(String[] args) { Outer out = new Outer(); out.method(); //直接访问内部类中的成员。 // Outer.Inner in = new Outer().new Inner(); // in.function(); } }
当外部类中的静态方法访问内部类时，内部类也必须是static的。
例子：
class Outer { private static int x = 3; static class Inner//静态内部类 { static void function() { System.out.println("innner :"+x); } } static class Inner2 { void show() { System.out.println("inner2 show"); } } public static void method() { Inner.function(); } } class Jiujiu { public static void main(String[] args) { new Outer.Inner2().show(); } }
16： 匿名内部类
就是内部类的简化写法。
前提：
•内部类可以继承或实现一个外部类或者接口。
格式为：
•new 外部类名或者接口名(){覆盖类或者接口中的代码， (也可以自定义内容。)}
简单理解：
•就是建立一个建立一个带内容的外部类或者接口的子类 匿名对象。
17：关键字instanceof
关键字：instanceof
用法：引用 instanceof 类名 判断这个引用所指向的对象是否属于这个类。
用在强制转换之前，避免类型转换异常。
if(a instanceof Dog){
Dog d=(Dog)a;
}
18：单例设计模式：
想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
步骤：
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。
class Single { private Single(){} private static Single s = new Single(); public static Single getInstance() { return s; } }
饿汉式：Single类一进内存，就已经创建好了对象
class Single { private Single(){} private static Single s = new Single(); public static Single getInstance() { return s; } }懒汉式： 对象是方法被调用时，才初始化，也叫做对象的延时加载
class Single { private static Single s = null; private Single(){} public static Single getInstance() { if(s==null) { synchronized(Single.class) { if(s==null) s = new Single(); } } return s; } }
19： 访问控制权限：
private：
本类内部可以访问
不能继承到子类
default：
本类内部可以访问，同包其他类也可以访问。
同包可继承
protected：
本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问。
能继承到子类
public：
任何地方都可以访问
能继承到子类
20： 封装类
Java为每一个简单数据类型提供了一个封装类。
除int和char，其余类型首字母大写即成封装类。
int Integer
char Character
最常用的两个封装类Integer和Double
jdk1.4之前基本类型和封装类的转化是需要构造器去转化的，到了jdk1.5是自动进行转化的
int、Integer和String之间的转化(最常用的)
int i=1;
Integer in = new Integer(i);//int --> Integer
int i = in.intValue();//Integer --> int
String str = String.valueOf(i);//Int --> String
int ii = Integer.parseInt(str);//String --> int
String s = in.toString();//Integer --> String
Integer inte = Integer.valueOf(str);//String --> Integer
21： Object类
hashCode()：
返回该对象的哈希码值
hashCode 的常规协定是：
在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用 的信息没有被修改。
如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
toString()：
返回该对象的字符串表示。
通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂。建议所有子类都重写此方法。
equals()
指示某个其他对象是否与此对象“相等”。
equals 方法在非空对象引用上实现相等关系：
自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y)始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有 被修改。对于任何非空引用值 x，x.equals(null) 都应返回 false。
注意：
当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
22： 模版方法设计模式
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去。由该类的子类去完成。
abstract class GetTime { public final void getTime() { long start = System.currentTimeMillis(); runcode(); long end = System.currentTimeMillis(); System.out.println("毫秒："+(end-start)); } public abstract void runcode(); } class SubTime extends GetTime { public void runcode() { for(int x=0; x<4000; x++) { System.out.print(x); } } } class TemplateDemo { public static void main(String[] args) { //GetTime gt = new GetTime(); SubTime gt = new SubTime(); gt.getTime(); } }
------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------
详情请查看：http://edu.csdn.net/heima/
扫一扫
3289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
