- 一个源文件中只能有一个声明为public的类，同时要求此类的类名与源文件名一致。
- 关键字：被java赋予特殊含义的单词，都是小写 。例如：class
- 标识符：变量，方法，类等要素命名时使用的字符序列称为标识符。规则(字符，数字，下划线，$，但是不能数字开头)
- 数组
- char类型默认值是空格
- float/double默认值是0.0
- boolean默认值是false
- int long byte short 默认是0
- 对于引用数据类型的变量，默认值是null(例如null)
- 内存分析
- 栈
- 局部变量
- 对象的引用
- 堆
- new出来东西(例如对象，数组)
- 方法区
- 方法/类/包等等的定义
- 字符串的常量池
- 静态域
- static修饰
- 栈
- 数组排序算法
- 冒泡排序
- 直接选择排序
面向对象
- 成员变量：声明在类里，方法外(有默认值，有public,private,protected,缺省值共四种修饰符，存在于堆空间中)
- 局部变量：方法内部的变量，代码块内部，形参(局部变量不能有修饰符，与所在方法修饰符相同)(必须初始化赋值，存在与栈空间中)
- 属性：类中的成员变量
- 行为：类中的成员方法
-
重载
- 方法名相同
- 同一个类中
- 方法参数列表不同(个数或类型不同)
- 和方法返回值没关系
public int getSum(int a,int b){ return a+b; } public int getSum(int a,int b,int c){ return a+b+c; } public double getSum(int a,int b,double c){ return a+b+c; } -
修饰符
- private:类内部使用
- 缺省值：类内部，同一个包
- protected：类内部，同一个包，字类
- public:全部可用
-
构造器
- 修饰符 类名(){}
class B { public int age; public String name; public B(int age) { this.age=age; } public B(int age, String name) { this(age); this.name=name; } } 说明：this指向最终调用者，此处有构造函数的重载，this(age)调用的是 第一个构造函数，且this()方式调用其他重载的构造函数的时候，必须在构造 函数的第一行。 -
继承
- 子类可以获得父类中声明的属性，方法。
- 父类中私有的属性和方法，字类同样可以获得，只是因为封装性，所以不能直接调用罢了，但是可以使用get,set等间接方式使用。
- 方法的重写
- 有继承关系
- 子父类有相同方法(返回值，方法名，参数列表必须相同)
- 子类方法修饰符不能小于父类修饰符
- 多态性(编译看左边，运行看右边)
- 要有类的继承
- 要有子类对父类方法的重写
- 所以父类对象是不能调用子类的特有方法的(不是重载的方法)，因为编译期都过不去，父类没有该方法
- 如果针对上一条，强制运行，可以让父类对象向下转型为子类，这样就可以调用了
- 子类对象的多态性，并不适用于属性
public class A { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub A a=new B(); a.getSum(); B b= (B) a; b.test(); //子类的属性不存在多态 System.out.println(b.num+"..."+a.num);//101 100 } public void getSum() { System.out.println("父类"); } } class B extends A{ public void getSum() { System.out.println("子类"); } public void test() { System.out.println("特有方法"); } } -
==
- 基本数据类型
- 根据基本数据类型的值进行转换比较
- 两边类型不同，向精确度更高的转换(例如 56=='A' true)
- 引用数据类型
- 比较地址是否相同
- 基本数据类型
-
equal
- 是Object的方法，所有对象都有
- 因为来源于Object，所以不能用于基本数据类型比较
-
String
- 针对string的==比较的是地址
- 针对string的equal比较的是内容
-
针对string都是存放在方法区的字符串常量池中的，所以不论是String a="AA",还是String b=new String("AA"),最终的"AA"对应地址都是同一个；之所以a==b结果是false，是因为，a在栈中指向的是"AA"真实地址，但是b指向的是堆里面new String("AA")的地址,而堆内部对应的地址才指向"AA".
1.png
-
toString
- 打印一个对象时候，默认调用就是这个对象的toString方法(sys=>p等效于sys=>p.toString())
-
如果对象所在类没有重写对应的toString方法，则调用就是Object的toString方法,输出是地址。
2.png
-
单元测试步骤：
- 右键项目，选中build path
- 选中add libiaries
- 在弹出窗选择junit,然后选择对应版本的junit版本
- 在主类(就相当于测试基础类,可以是任意类。)可以编写写测试代码(无参数无返回值的方法)
- 在测试方法上面添加@Test的注解(需要导test入包)
- 鼠标双击方法名，run as =>junit test
-
如果绿色标志证明运行正常，否则程序有错误
3.png
-
static
static修饰属性：
- 由类创建的所有对象，都公用这一个属性
- 类变量存在于静态域中- static修饰方法(类方法)：
- 随着类的加载而加载，在内存中也是独一份
- 类.类方法调用
- 因为最先加载，所以只可以使用静态的属性和方法，不能使用实例方法和属性(此时还没随类加载)
- 静态方法里面不可以有this/super
- static修饰方法(类方法)：
-
单例模式(一个类只能存在一个实例对象)
- 饿汉式
/**
* 饿汉式：开发时候常用
*
* @author Administrator
*
*/
class Singleton {
private static Singleton sg = new Singleton();
private Singleton() {
}
public static Singleton getSingle() {
return sg;
}
}
* 懒汉式
/**
* 懒汉式：可能存在线程安全问题
*
* @author Administrator
*
*/
class Singleton {
private static Singleton sg;
private Singleton() {
}
public static Singleton getSingle() {
if (sg == null) {
sg = new Singleton();
}
return sg;
}
}
- final
- final修饰的类不能被继承
- final修饰方法不能被重写
- final修饰属性，此属性就是一个常量，常量必须显式赋值(没有默认值，赋值时间只要是对象初始化之前即可)
- 如果static final修饰属性，说明该属性是全局常量
补充：final修饰很多时候是为了避免变量释放
public class INClass{
void innerClass(final String str){
class IClass{
IClass(){
System.out.println(str);
}
}
IClass ic=new IClass();
}
public static void main(String[] args){
INClass inc=new INClass();
inc.innerClass("Hello");
}
}
说明：final修饰str，否则方法执行完毕会释放str，但是此时内部类还需要使用str。
所以利用final修饰避免释放保证内部类使用正常。此处java的内存回收应该不是引用计数，
否则不会出现这种情况，具体后期研究。
抽象类
- abstract修饰类:抽象类
- 不可以被实例化
- 抽象类有构造器(凡是类都有构造器)
- 抽象类中可以没有抽象方法
- 抽象类中可以存在抽象方法和实例方法
- abstract修饰的方法：抽象方法
- 没有方法体(public abstract eat();)
- 抽象方法只保留方法的功能，具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
- 抽象方法所在类必须是抽象类
- 子类继承抽象类，实现全部抽象方法，则子类就是实体类可以实例化，否则此类也是抽象类
- 模板方法设计模式
当功能内部一部分实现是确定，一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类实现
public class D {
/**
* @param args
*/
public static void main(String[] args) {
//下面两种等效
// ABTemplate ab=new Template();
Template ab=new Template();
ab.getTime();
}
}
abstract class ABTemplate{
public abstract void code();
public void getTime() {
long t1=System.currentTimeMillis();
this.code();
long t2=System.currentTimeMillis();
System.out.println(t2-t1);
}
}
class Template extends ABTemplate{
@Override
public void code() {
int total=0;
for (int i = 0; i < 1000; i++) {
total+=i;
}
System.out.println(total);
}
}
说明：这样形式就可以实现一部分固定，一部分子类实现。
接口
- 接口是抽象方法和常量值的定义的集合。
- 本质上：接口是特殊的抽象类
- 接口可以多实现
- 接口针对功能
- 接口没有构造器
- 接口之间可以继承(而且可以多继承)
- 接口和实现类之间也符合多态性
public interface One {
//接口中只能放常量，所以即使不加public static final修饰，默认也会加上
public static final int num=0;
String info="测试";
//接口中只能有抽象方法，所以下面两者等效，默认加上public abstract修饰
public abstract void test();
void getName();
}
class BB implements One{
public void test() {
System.out.println(num);
}
public void getName() {
System.out.println(info);
}
}
- 工厂方法模式
定义一个创建对象的接口，让子类决定实例化哪一个类
public class FactoryTest {
/**
* @param args
*/
public static void main(String[] args) {
WorkFactory wf=new StudentWorkFactory();
wf.getWork().doWork();//学生写作业
WorkFactory wf1=new TeacherWorkFactory();
wf1.getWork().doWork();//老师批改作业
}
}
interface WorkFactory{
Work getWork();
}
class StudentWorkFactory implements WorkFactory{
public Work getWork() {
return new StudentWork();
}
}
class TeacherWorkFactory implements WorkFactory{
public Work getWork() {
return new TeacherWork();
}
}
interface Work{
void doWork();
}
class StudentWork implements Work{
public void doWork() {
System.out.println("学生写作业");
}
}
class TeacherWork implements Work{
public void doWork() {
System.out.println("老师批改作业");
}
}
- 静态代理模式
为其他对象提供一种代理以控制对这个对象的访问
代理类负责了被代理类的执行
public class TestProxy {
/**
* @param args
*/
public static void main(String[] args) {
Object b=new Px1();
b.action();
}
}
interface Object{
void action();
}
class Px1 implements Object{
Px2 p2;
public Px1() {
p2=new Px2();
}
public void action() {
System.out.println("代理执行开始");
p2.action();
System.out.println("代理执行结束");
}
}
class Px2 implements Object{
public void action() {
System.out.println("被代理执行开始");
System.out.println("被代理执行结束");
}
}
输出：
代理执行开始
被代理执行开始
被代理执行结束
代理执行结束
内部类
- 成员内部类(类里方法外)
- 局部内部类(类的方法里)
匿名内部类
public class InnerClass {
/**
* @param args
*/
public static void main(String[] args) {
InnerClass ic=new InnerClass();
ic.show(new Imple() {
public void test() {
System.out.println("测试");
}
});
}
public void show(Imple p) {
p.test();
}
interface Imple{
void test();
}
}
