通过这两天的学习,小卷似乎开始知道一些java程序编写的端倪,他开始回忆这两天零散的知识点:
我们想让计算机帮我们实现一些计算,会先定义一些变量,变量约定了数据的类型和存在内存中的地址,然后让变量之间发生作用,比如判断某个变量,做一些运算,运算过程可以循环迭代进行,最后就会得到我们想要的结果。
可是,总觉得哪里不对,又说不出来……
我看到的软件开发是这样的:
我自己经历的软件开发是这样的:
老师明白了小卷的疑惑,长舒了一口气,慢慢说:万丈高楼平地起!你现在经历的和你想象中的并不矛盾,你现在经历的就是一砖一瓦的建设,再配合其他各方面的砖瓦配合,比如:UI、前端、运维,就会达到你想要的效果。
简单的说来就是这样,你以后就会明白的:
老师接着说,今天我们就开始讲有趣一些的东西,前两天也是在太枯燥了。
类与对象
类简单来说就是一个模板、一个抽象的概念,既然是抽象的,就没有具体的实物对应,比如:人、树、花、鸟、虫……他们都是抽象的;
对象是具体的万事万物,比如你小卷、昨天死在你们家窗台上的那只小强都是对象,小卷的胳膊是对象,小卷的头发也是对象,头发里的细胞也是对象,总之一句话:万物皆对象!
我们为什么要面相对象编程?还记得前面买西瓜的老张吗?这事他最清楚了,让我们来回顾一下:
老张的老婆让老张下班的时候买一斤包子回家,如果有卖西瓜的,买一个!
我们简单的把这句话的动名词分一下,这里只涉及我们关心的,比如“下班”、“卖”也是动词,但是不是我们现在关心的,可以忽略;
于是名词可以作为对象,动词可以作为对象中的方法,谁要做这个动作,谁就有这个方法,很显然,在这里,老张有买的方法,老张老婆有指挥老张的方法,因此我们可以编写这样的类
public class BaoZi {
private String unit;
public BaoZi(String unit) {
this.unit = unit;
}
@Override
public String toString() {
return unit + "包子";
}
}
public class XiGua {
private String unit;
public XiGua(String unit) {
this.unit = unit;
}
@Override
public String toString() {
return unit + "西瓜";
}
}
public class LaoZhang {
public Object buy(String command){
if("买一斤包子".equals(command)){
System.out.println("我是老张,我买了一斤包子");
return new BaoZi("一斤");
}else if("看到卖西瓜的,买一个".equals(command)){
System.out.println("我是老张,我买了一个西瓜");
return new XiGua("一个");
}else if("买一斤包子,如果看到卖西瓜的,买一个".equals(command)){
System.out.println("我是老张,我买了一个包子,因为我看见卖西瓜的了");
return new BaoZi("一个");
}else{
return null;
}
}
}
public class LaoZhangLaopo {
//我家老张
private static LaoZhang laoZhang = new LaoZhang();
public static void command(String command){
Object obj = laoZhang.buy(command);
System.out.println("发个朋友圈:我跟老公说"+command+",老公买回来"+obj);
}
public static void main(String[] args) {
//第一次命令
command("买一斤包子");
//第二次命令
command("看到卖西瓜的,买一个");
//第三次命令
command("买一斤包子,如果看到卖西瓜的,买一个");
}
}
执行结果:
我是老张,我买了一斤包子
发个朋友圈:我跟老公说买一斤包子,老公买回来一斤包子
我是老张,我买了一个西瓜
发个朋友圈:我跟老公说看到卖西瓜的,买一个,老公买回来一个西瓜
我是老张,我买了一个包子,因为我看见卖西瓜的了
发个朋友圈:我跟老公说买一斤包子,如果看到卖西瓜的,买一个,老公买回来一个包子
在这个例子中,我们用4个类及类中的方法逻辑来表达了这件事情,这种清晰的、以对象为建模中心、以调用者来组织这些模型对象表达业务的方式就是面向对象编程,也就是说,只要我们能把需求说清楚,就能把代码写明白,直观而且代码好管理,易维护。
那么如上所示的4段代码我们叫他类,为什么不叫对象呢?因为这些代码只是对对象的定义,比如一块砖长100cm,宽50cm,高20cm,这3个属性是我们定义的砖的属性,是我们用来描述砖的载体,但是并不等于砖,假如我们忽略砖的其他细节,就认为这3个属性就可以描述一看砖了,那么这三个属性就成了一个模板,这就是类。
那什么是代码中的对象呢?
比如这句代码: return new BaoZi("一斤");
就是用BaoZi这个类为模板创建了一个包子对象,这个对象的属性是“一斤”
使用new关键字创建一个实例对象的时候,其实是调用了类中的构造器
A类的构造器的写法示例:
public A(){
//这是A类的一个无参数构造器
}
public A(int a){
//这是A类的一个带一个参数构造器,一般用来给对象的属性赋初值
}
构造器的写法和类方法有些类似,但是有以下不同:
一、构造器没有返回方法,因为返回的就是类的实例
二、名称必须和类名一模一样
如果一个类中没有编写构造器,那会自动存在一个默认的构造器,如:
class A{}
那么这个类中默认存在一个公有的无参构造器 public A(){}
构造器中没有逻辑,这个对象中的属性都会赋予默认初值。
但是,当你手工编写了一个有参数构造器后,就不会默认存在一个无参的构造器了!因此,在使用一些框架的时候,如果框架需要通过代理创建对象实例,务必编写一个无参构造器!
一个类可以有若干个构造器,但是参数列表必须不同,这叫构造器重载。
类中的方法也可以重载,但是因为普通方法有返回值,所以,普通方法的重载和类重载有一些区别:
方法的重载只要参数列表不同或返回值不同都是可以的,如:
public void abc(){}
public int abc(){}
public void abc(int a){}
重载通常用于我们想表达同一个业务意义,但是有不同的处理逻辑的时候。
封装、继承、多态
类的封装特性是通过修饰符private、protected、public来体现的。
比如有一个小卷的类,里面有他的身高,体重,姓名,但是这些都是小卷要么不想告诉别人,要么不想被别人修改的属性,那么我们就可以用private来修饰,其他人无权查看和修改;
再比如小卷觉得不能被修改,但是还是可以告诉别人,那么我们可以通过提供公共的查看方法,这样别人就能看到,但是不能修改了;
再比如小卷又觉得既可以告诉别人,也可以被别人修改,那么我们仍然希望通过提供公共的查看和修改方法给别人,而不是直接修改属性,这两者看上去没区别,但是还是有一些不同的;
不同一:可以通过方法的权限,比如改为protocted,限制一部分人拥有查询修改的权限
不同二:可以通过修改方法类的逻辑,限定在某些逻辑下才可以查看和修改
类的继承就比较直观,字面意思,“继承”就ao像人类的父子之间有继承权一样
类的继承用关键字extends 表达,如类A继承于类B
class A extends B,B是父类,A是子类
java类的继承是单继承,因为只能有一个爸爸,但是一个爸爸可以有很多个孩子,所以一个父类可以被多个子类继承。
A类可以继承B类所有的非私有属性和方法,不能继承私有属性和方法,正如父亲的一些东西是孩子可以继承的,但是也有自己隐私的东西一样。
class A {
private int age;//年龄
public String lastname;//姓
public void say(){
//说话方式
System.out.println("经常说:啊……这个");
}
}
class B extends A{}
这种情况下,B类可以继承A类的姓和说话方式的方法,但是不能继承A的年龄。
B b = new B();也可以写为:A b = new B();
b.say();
也会执行:经常说:啊……这个
多态是java中发生继承关系的情况下产生的一种方法动态绑定
例如前面的例子中,如果
class B extends A{
public void say(){
//说话方式
System.out.println("经常说:啊……那个");
}
}
子类中存在一个和父类方法名相同,返回类型相同,参数列表也相同的方法的时候,这叫重写,那么当我们实例化两个对象
A a = new A();
A b = new B();
的时候,用a.say()和b.say()是不一样的,尽管两个实例对象都是用A类型来申明,但是执行方法的时候,会根据自己实际的构造类型执行对应的方法。
a对象执行的say就是:经常说:啊……这个
b对象执行的say就是:经常说:啊……那个
成员内部类、静态内部类、方法内部类、匿名内部类
通常有一些类,我们认为是某个类的复杂属性,不能用基本类型表达,但这个类又不会在其他地方引用,仅仅是这个类中自己使用的一部分,我们就可以用内部类,这样具有更好的封装性,如:
class A {
private int a;
class B{
private int b;
int c;
}
}
这个时候,B就是A的一个成员内部类。
内部类B可以直接访问A的私有成员变量a,而A中访问B中的b需要用B的实例对象来访问;
创建B的实例对象需要在A的实例对象下才能创建(皮之不存毛将焉附?)
B不是A的一部分,他们可以有独立的业务逻辑
在A中可以通过B b = new B();创建内部类
在A外的其他类中只能通过A.B b = new A().new B();创建
静态内部类的写法和成员内部类类似,只是加上了静态修饰符
class A {
private int a;
public static class B{
private int b;
int c;
}
}
静态内部类的特点是可以不依赖外部类实例创建,就像静态变量一样
B b= new B();
方法内部类是在方法的内部创建的类
class A {
private int a;
public void a(){
class B{
private int b;
int c;
}
B b = new B();
}
}
这种内部类只能在方法的内部使用
匿名内部类是我们在创建的时候就省略了名字的内部类,有些时候,我们创建的内部类只用一次。
public class A {
public void abc(){
System.err.println("11111111111");
}
public static void main(String[] args) {
new A(){
public void abc(){
System.err.println("22222222222");
}
}.abc();
}
}
这里我们只创建对象后使用一次,由于别的对方没有使用这个对象的需要,不用申明一个变量来指向该对象。
上一篇:第二回 小卷学语法



