程序的三个基本机构:1、顺序结构 2、选择结构 3、循环结构
面向对象是一种更为优秀的程序设计方法,它的基本思想是使用类、对象、继承、封装、消息等基本概念进行程序设计。
面向对象的三个基本特征:封装、继承和多态。
封装:将对象的实现细节封装起来,然后通过一些公用的方法来暴露该对象的功能。
继承:是面向对象实现软件复用的重要手段,子类继承父类,子类将直接获得父类的属性和方法。
多态:子类对象可以直接赋给父类变量,但是在运行时依然表现出子类的行为特征,这意味着同一个类型的对象在执行同一个方法时,可能表现出多重行为特征。
类和对象的关系:
类是对象的抽象,而对象是类的实例。对一个类的定义而言,包含了三种最常见的成员:构造器、成员变量和方法。
static是一个特殊的关键字,可以用于修饰方法和成员变量,被static修饰表明属于类本身,而不属于该类的单个实例,因此成为类变量和类方法,而实例方法与其不同,访问该类的成员和方法不受限制。
UML(统一建模语言)
面向对象软件开发需要经过OOA(面向对象分析)、OOD(面向对象设计)和OOP(面向对象编程)的三个阶段。
Java语言支持的类型分类:基本类型和引用类型。
基本类型
整数类型:byte(1个字节)、short(两个字节)、int(4个字节)和long(8个字节)
字符类型:char(2个字节)
浮点类型:float(4个字节)、double(8个字节)
布尔类型:boolean
整数值的4种表示方式:0b或0B表示二进制、o表示八进制、0x或者oX表示十六进制。
整数值默认是int,占32位,例如0b11101001,如果加L或者l,这个二进制默认占64位。
字符型值也可以用十六进制表示,范围是'\u0000'~'uFFFF',和ASCII码中的字符完全重合。
负数在计算机中以补码的形式出现。
浮点类型默认是double类型。
类型的强制转换和表达式自动提升。强制转换,右边的范围一般高于左边。自动提升注意赋值的左右两边类型一致,否则报错。
++:自加(自减)
如果把++放在左边,则先把操作数加1,再把操作数放入表达式中运算,如果++放在右边,则先把操作数放入表达式运算,在把操作数加1。
<<:左移运算符
>>:右移运算符,左边空出来,负数补1,整数补0。即以符号位填充。
>>>:无符号右移运算符,左边空出来的总是补0。
对低于int类型的数据,先转换为int类型,再进行移位。对于移位大于被移位数据类型时,要进行先求余,再移位。
break、continue、return、foreach用法。
2.引用类型
数组是一种引用数据类型,数组元素和数组变量在内存里是分开存放的。数组引用变量只是一个引用,这个引用可以指向有效内存的任何地方。实际数组对象存储在堆内存中,引用该数组的变量是一个局部变量,存储在栈内存中。
堆内存和栈内存有什么区别?
当一个方法被调用时,每个方法就会建立自己的内存栈,在这个方法内定义的变量将被逐个放入该内存中,随着方法的结束,这个方法的内存也就销毁了,而在程序中创建一个对象时,这个对象就会被放在堆内存中,以便反复利用,即使方法结束对内存的对象也不会内销毁,有可能被另一个引用变量引用,除非没有其他引用,Java虚拟机的垃圾回收机制在合适的时候自动回收该对象。
关键字:this
对象的this引用:对象的一个方法依赖(调用)于另一个方法的情形。大部分时候,一个方法访问该类中的其他方法、成员变量时,可以省略this,效果是一样的。但是,对于static修饰的方法而言,使用this无法指向合适的对象,所以被static修饰的方法不能够访问非静态的成员。因此Java语法规定:静态成员不能够访问非静态成员。
尽可能使用类名调用静态方法,因为该静态方法是属于类的,不属于该类的实例。
方法的理解
Java里的方法不能够独立存在,调用方法必须使用类或者对象。
参数传递的机制:基本类型和引用类型的参数传递。基本类型情况下,就是将实际参数复制到传入的方法中,参数本身不受影响;而引用类型传递的引用变量给形参,实参和形参同时指向同一个对象,通过形参改变对象的值,实参所指向的对象也将改变。
递归方法的一个重要原则:递归一定要向已知的方向递归。
方法重载
重载:发生在同一个类中,方法名必须相同,参数类型不同、个数不同、顺序不同,方法返回值和访问修饰符可以不同,发生在编译时。
成员变量和局部变量
成员变量包括:实例变量和类变量,类变量的范围大于实例变量的范围,同一个类的所有实例访问类变量时,实际上访问的是该类同一片内存区域的一个变量。
class Person{//实例变量public String name;//类变量public static int eyeNum;}//创建第一个Person对象Person p1 = new Person();//创建第二个Person对象Person p2 = new Person();//分别给两个对象的name实例变量赋值p1.neme = "张三";p2.name = "孙悟空";//分别给两个Person对象的eyeNum类变量赋值p1.eyeNum = 2;p2.eyeNum = 3;
局部变量包括:形参、方法局部变量和代码块局部变量。
访问代码块局部变量之前必须初始化,否则出错。离开了代码块局部变量所在的代码块,这个局部变量也就被销毁了。
局部变量会覆盖成员变量,成员变量依然可以使用this和类名来调用。
类加载器先初始化类,然后创建实例,eyeNum是属于类的,并不属于Person对象,创建第一个实例对象时,系统并不需要为eyeNum分配内存,只是为实例变量name分配了内存。如果再创建第二个Person对象,不需要对Perso类进行初始化。
与成员变量不同的是,局部变量不属于任何类和实例,因此它总是保存在其所在方法的栈内存中,基本类型的变量保存的是值,引用类型的变量保存的是地址。
访问控制符:private,protected,public
import 和static import
使用import可以省略写包名,使用static import则可以连类名就能省略。
构造器
构造器初始化,构造器重载
例如使用this(name.color)调用另一个构造器的初始化代码。
类的继承
重写父类的方法,父类private方法不能够子类重写(覆盖),该方法对其子类是隐藏的。
重写:“两同两小一大原则”,发生在父子类中,方法名、参数列表必须相同,返回值范围小于等于父类,抛出的异常范围小于等于父类,访问修饰符范围大于等于父类;如果父类方法访问修饰符为 private 则子类就不能重写该方法。
关键字super
super调用父类被覆盖的方法,调用父类的变量和方法。子类实例变量名和父类实例变量名相同,子类会隐藏父类的实例变量。可以使用super.变量访问父类的实例变量。
如果在某个方法中访问变量a,(1)先查找该方法中是否有局部变量(2)查找当前类是否有该成员(3)查找直接父类是否有该成员变量,进而追溯上一级的父类,知道找到该变量,否则编译错误。
调用父类的构造器super(name,color),子类构造器调用父类构造器时,super语句必须放在子类构造器的第一行。
创建任何一个java对象时,最先执行的Object类的构造器。执行原则:从该类所在继承树最顶层类的构造器开始执行。
多态性
如果编译时类型和运行时类型不一致,当运行时调用该变量的方法时,其方法行为总能够表现出子类方法的行为特征,而不是父类方法的行为特征,这就是传说中的多态。另外注意一条原则:编译看左边,运行看右边。
在开发中首先使用instanceof运算符判断是否具备该类的特性,然后用(type)强制转换,增加了程序的健壮性,而且不会出现错误。
继承和组合
都能够实现类的复用手段,但是继承会破会封装,组合提供更好地封装,组合很常见啊,Spring中注入bean,就是组合。
初始化块
这是在笔试题中经常遇到的问题,java类四个成员,成员变量,方法,构造器和初始化块。
初始化代码块的修饰符只能是static,称为静态代码块。
先执行实例变量的赋值,再执行代码块的赋值。
先执行代码块,再执行构造器。
静态代码块不管顺序如何,都会在main函数之前执行。
Java初始化的顺序:父类静态变量-->父类静态代码块-->子类静态变量-->子类静态代码块-->父类非静态变量-->父类菲静态代码块-->父类构造函数-->子类非静态变量-->子类菲静态代码块-->子类构造函数
普通初始化块、声明实例变量指的默认值都可认为对象的初始化代码,它们执行的顺序和源程序的顺利一致。
public class Demo1 {{a = 6;System.out.println("a = 6;");}int a = 9;public static void main(String[] args){System.out.println(new Demo1().a);}}
public class Demo1 {int a = 9;{a = 6;System.out.println("a = 6;");}public static void main(String[] args){System.out.println(new Demo1().a);}}
静态初始化块、声明静态成员变量指的初始值可认为是该类的初始化代码,它们执行的顺序和源程序的顺利一致。
public class Demo1 {static {a = 6;System.out.println("a = 6;");}static int a = 9;public static void main(String[] args){System.out.println(new Demo1().a);}}
public class Demo1 {static int a = 9;static {a = 6;System.out.println("a = 6;");}public static void main(String[] args){System.out.println(new Demo1().a);}}
基本类型和包装类的对应。
parseXxx(String s)String.valueOf(基本类型)
打印对象和toString()方法
package com.quan.sort.fastsort;public class Demo1 {public static void main(String[] args) {Person p = new Person("zhangsan");System.out.println(p);System.out.println(p.toString());}}class Person{String name;Person(String name){this.name = name;}}
结果:类全名+@+十六机制的哈希值
为什么是这样的格式???com.quan.sort.fastsort.Person@1540e19d
Person继承了Object类的toString方法。源码分析:
==和equals方法
如果比较的是两个基本类型的值,只要值相同就返回true。引用类型的比较,必须指向同一个对象才能够返回true。
"abc"和new String("abc")的区别?"abc"编译时就计算出来的字符串值,JVM将会使用常量池管理这些字符串。而是用new String("abc")时,JVM将会使用常量池管理这个直接量,然后再调用String类的构造器创建一个新的String对象,新创建的String对象放在堆内存中。换句话说,new String("abc")一共产生了两个字符串对象。
JVM常量池保证相同的字符串只有一个,不会出现副本。
String类中的equals方法比较的是引用变量所指对象的值相等,就会返回true,因为重写了Object的equals方法。
public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;}
严格上说equals方法,是具体的实现,想怎么相等就怎么相等。全部自己做主。
final关键字修饰类、变量和方法
final变量:被final修饰的基本类型的变量只能赋值一次,不能够再次改变被final修饰的引用变量不能够被重新赋值,但是引用变量所指对象的值可以改变。
final方法:被final修饰的方法不能够被重写,但是可以被重载。
final类:不可以有子类,保证不被继承。
不可变类:8个包装类 和 String类
Integer的缓存范围为-128~127.
Integer in1 = new Integer(6);//创建一个新的对象,并缓存该对象Integer in2 = Integer.valueOf(6);//直接冲缓存中取出该对象Integer in3 = Integer.valueOf(6);System.out.println(in1 == in2);System.out.println(in3 == in2);