Java基础——名词解释

1）类与对象

类：生活中一些对象共同点的集合、主观的、以人的意识存在的

对象：客观存在的，类的实体

2）面向对象

java是一门面向对象的开发语言，c是面向过程的开发语言，两种编程思想的不同：

生活中一件事  = 对象（执行者） + 过程（执行流程）

面向对象————关注对象（关注事情的执行者） ->>结果不确定（灵活）
面向过程————关注过程（关注事情的执行流程） ->>结果确定（死板）

面向对象三大特性：继承性、多态性、封装性

3）基本语法：

1.一个类对应一个java文件
2.属性（特征）的定义格式：访问权限 类型 属性名;
3.方法（行为）的定义格式：访问权限 返回类型 方法名（参数列表）｛｝
4.创建对象的格式：类名 对象名 = new 类名（）；
5.调用属性：对象名.属性名
6.调用方法：对象名.方法名（参数）

7.程序入口：public static void main(String[] args){}

代码示例1.1：

package pra01;

public class teacher {
	//属性
	public String tname;
	//方法
	public void teach(String sname){
		System.out.println(tname + "老师给" + sname + "学生讲课");
	}
}

<pre name="code" class="java">package pra01;

public class text {
	//入口
	public static void main(String[] args){
		//创建对象
		teacher tc = new teacher();
		//调用属性
		tc.tname = "Jack";
		//调用方法
		tc.teach("Tony");
	}
}

运行结果：

访问权限：

如果没有写就是默认访问权限。
java的类有2种访问权限，public、默认
而方法和变量有4种：public、默认、protected、private
其中默认访问权限和protected很相似，有着细微的差别。
public意味着任何地方的其他类都能访问
默认则是同一个包的类可以访问。
protected表示同一个包的类可以访问，其他的包的该类的子类也可以访问。
private表示只有自己类能访问

4）构造器（构造方法）

作用：完成对象的初始化，创建对象时自动调用，默认返回值为地址，可以重载

格式：

普通方法格式：public 返回类型 方法名（参数列表）｛｝

构造方法格式：public 类名（参数列表）{}

原理：

堆内存用来存放由new创建的对象和数组

栈中变量的取值等于数组或对象在堆内存中的首地址，使用变量来访问堆中的内容

5）方法重载

定义：同一个类中，多个方法方法名相同，参数列表不同（参数个数、参数类型、参数顺序至少有一个不一样）※返回值类型不足以区别是哪个方法

构造函数的重载：创建一个对象时，只能调用一个构造函数

举例：JButton的重载

 <span style="white-space:pre">	</span>JButton jb1 = new JButton();
	jb1.setText("关机");

  与

<span style="white-space:pre">	</span>Button jb1 = new JButton("关机");

对于JButton一个有参，一个无参
同时这也是构造函数的重载，关于JButton的构造函数重载，可由API查得

6）继承（子类和父类）

关键字：extends

定义：子类可以继承父类的所有非私有属性和方法，子类可以有额外的属性和方法

作用：动态的拓展类的功能，一般情况下子类比父类更强大

代码举例：

package pra01;

public class human {
	//父类属性
	String sex;
	String name;
	//父类
	public void eat(){
		System.out.println("Human beings need to eat");
	}
}

package pra01;

public class chef extends human{
	//子类自己的方法
	void cook (){
		System.out.println("厨师可以烹饪");
	}
}

package pra01;

public class text {
	//入口
	public static void main(String[] args){
		//创建子类对象
		chef a = new chef();
		//调用继承来的属性name和sex
		a.name = "Tom";
		a.sex = "male";
		//调用继承来的方法
		a.eat();
		//调用子类自己的方法
		a.cook();
	}
}

运行结果：

7）方法重写

定义：子类重写父类的方法，方法名、参数、返回类型必须相同

作用：用于覆盖父类继承过来的方法

举例：重写eat类

package pra01;

public class chef extends human{
	//子类额外方法
	void cook (){
		System.out.println("厨师可以烹饪");
	}
	public void eat(){
		System.out.println("chefs are the master of eating");
	}
}

运行结果：

重写后输出结果为重写后的eat方法

8）转型：父类引用指向子类引用

定义：无论是上转还是下转都是为了让类的使用范围和适用范围发生变化，以便操作不同范围的变量或者方法。

1）上转型是指将子类对象使用父类引用进行引用。通俗地说就是是将子类对象转为父类对象。
得：上转型对象可以操作和使用子类继承或者重写的方法。
失：上转型对象丧失了对子类新增成员变量或新增的方法的操作和使用。
2）与向上转型相反，即是把父类对象转为子类对象：作用也与上转相反。向下转型需要用到强制类型转换。

向上转型代码举例：

若把上面代码的主函数部分改成

		human a = new chef();<span style="white-space:pre">	</span>//向上转型，

		a.eat();	<span style="white-space:pre">	</span>//调用父类eat方法，a遗失chef类方法cook

则，调用eat方法时，结果为重写后的

且，子类chef自己的方法cook不能调用，编译报错

9）多态

定义： 指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

作用：消除类型之间的耦合关系。

理解：现实中多态的举例有很多，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

多态存在的三个必要条件
1）要有继承
2）要有重写
3）父类引用指向子类对象

多态的好处：

1.可替换性。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
4.灵活性。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

关于多态的一个练习：

class A ...{  
         public String show(D obj)...{  
                return ("A and D");  
         }   
         public String show(A obj)...{  
                return ("A and A");  
         }   
}   
class B extends A...{  
         public String show(B obj)...{  
                return ("B and B");  
         }  
         public String show(A obj)...{  
                return ("B and A");  
         }   
}  
class C extends B...{}   
class D extends B...{}

问题：以下输出结果是什么？

A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();   
        System.out.println(a1.show(b));   ①  
        System.out.println(a1.show(c));   ②  
        System.out.println(a1.show(d));   ③  
        System.out.println(a2.show(b));   ④  
        System.out.println(a2.show(c));   ⑤  
        System.out.println(a2.show(d));   ⑥  
        System.out.println(b.show(b));    ⑦  
        System.out.println(b.show(c));    ⑧  
        System.out.println(b.show(d));    ⑨

分析：
a1是A类的一个对象，包含的方法为show（A）、show（D）
b是B类的一个对象，包含的方法为重写后的show（A）、show（B）、show（D）
a2是B类向上A类转型，没有重写，所以遗失了自身的show（B）函数，
重写了show（A），包含的方法为重写后的show（A）、show（D）
c是C类的一个对象，包含的方法为重写后的show（A）、show（B）、show（D）
d是D类的一个对象，包含的方法为重写后的show（A）、show（B）、show（D）

	①   A and A
	②   A and A
	③   A and D
	④   B and A
	⑤   B and A
	⑥   A and D
	⑦   B and B
	⑧   B and B
	⑨   A and D

注：这部分参考自 点击打开链接

10）当前类对象this

理解：代码执行前，或没执行到之前，this是没有指向的，执行时，指回当前对象，如果类有属性，this.XXX就是指这个类的xxx属性，有方法的，this.xx().就是指这个类的xx()方法。

理解举例：

package pra01;

public class A {
	int i = 10;
	void a1(){
		System.out.print("这是a1");
	}
	void a2(){
		a1();
		System.out.print(i);
	}
	
}

上边这个例子 a2()里调用a1()和i的时候一般都是这么写的， 可以实际上前边都是的有this的， 只不过是没写出来罢了， 上边的例子本来应该是

package pra01;

public class A {
	int i = 10;
	void a1(){
		System.out.print("这是a1");
	}
	void a2(){
		this.a1();
		System.out.print(this.i);
	}
	
}

关于本章内容的练习，做了一个简单的窗口，单机按钮实现简单的关机、运行qq、打开浏览器操作

代码地址：

https://github.com/EsionChang/Java/blob/master/ComputerOperationFrame.java