突然就开始学JAVA了,很不习惯啊,但是再不学课设就要玩完了呜呜呜呜
封装(Encapsulation)
面向对象的基本特征
将用户需要的内容暴露,隐藏细节;将内容分门别类进行管理
1、包级封装:将类分门别类放在包中,便于管理
- 如何将类放在某个包中(以文件夹进行管理)
在类的定义上,标明: package 包名;
要点:- 编程规范:包的名字首字母一般小写
- 可以定义包中的子包,定义时用 . 隔开
- 用.定义的子包,和上层的包,并无隶属关系,只是各自的包名定义 bank bank.person 不是包含关系,这两个包是不同的包
如何使用某个包中的类
- 同一个包中的类,可以直接使用
- 不在同一个包中的类,需要用
import 类路径 来导入。(前提:被导入的类是public类)
import 包名.*; 导入包中的所有类
如下:
package bank.person;
class Customer{
String account;
double balance;
public static void main (String[] args) {
}
}
package bank;
import bank.person.*;
class Manager{
String account;
int id;
public static void main (String[] args) {
Customer cus = new Customer();
}
}
2、类级封装
主要特指:前面所述的 public类
public类在定义时,增加public关键字 public class XX{}
- 规定:public类类名必须和类所在文件名相同
- 性质:只有public类才能被包外的类导入并访问,普通类只能在同一个包中被访问
如下:
(public类)
package bank.person;
public class Customer{
String account;
double balance;
public static void main (String[] args) {
}
}
(默认类)
package bank;
import bank.person.*;
class Manager{
String account;
int id;
public static void main (String[] args) {
Customer cus = new Customer();
}
}
3、成员级封装:定义各个成员被外界访问的权限
权限有4种:
- private:私有 只在类中能被访问
- 无修饰:默认 能在类中访问;也可被同一包中其他类访问
- protected:保护 默认权限+可被包外子类访问
- public:公开 可被包内包外所有类访问
要点:- 建议:成员变量定义成私有;成员函数定义成公有
- 通过成员函数来访问成员变量,确保访问安全
如下:
package bank.person;
public class Customer{
String account;
private double balance;
public void display(){}
public static void main (String[] args) {
Customer cus = new Customer();
cus.balance = 1000;
}
}
package bank;
import bank.person.*;
class Manager{
String account;
int id;
public static void main (String[] args) {
Customer cus = new Customer();
//cus.balance = 1000;
//cus.account = "zs";
cus.display();
}
}
习题
编写代码,实现单例模式(某个对象在系统使用的过程中,永远保持不多于1个),以Windows的任务管理器为例
class TaskManager{
private static TaskManager tm = null;
private TaskManager(){
System.out.println("任务管理器初始化");
}
public static TaskManager getInstance(){
if(tm==null) { tm = new TaskManager();}
return tm;
}
public void display() { System.out.println("任务管理器显示");}
}
class Desktop{
public void click(){
TaskManager.getInstance().display();
}
public static void main (String[] args) {
Desktop d = new Desktop();
d.click(); d.click(); d.click();
}
}
继承
1、为什么需要继承
降低代码量,提高系统可维护性
2、如何实现继承?
- 将共同的代码编写一个类
- 将个体代码分别编写类
- 个体代码继承共同代码类
如何继承?关键字:extends
要点:
- (1)FontDialog继承Dialog,FontDialog叫做子类,派生类或者扩展类;Dialog又叫做父类,基类或者超类
- (2)子类继承父类之后,父类中的成员可以像子类自己的成员一样被子类对象使用(私有的父类成员除外)
- (3)如果父类成员被子类使用,一般将父类成员定义为protected
- (4)Java不支持多重继承(同时继承多个父类)
class Dialog{
int w;
int h;
}
class FontDialog extends Dialog{
String fontName;
}
class ParaDialog extends Dialog{
int lineWidth;
}
class Test{
public static void main (String[] args) {
FontDialog fd = new FontDialog();
fd.w = 100;
}
}
3、子类中可否定义和父类格式相同的成员?
- 可以;此时子类对象调用时子类中的成员
- 该内容称为“覆盖”(override),或者“重写”
要点: - 覆盖时,不允许使得子类成员的访问权限更加严格
4、覆盖有何作用?
- 可以通过覆盖,实现子类对象某些属性或功能的个性化定制
5、如何在子类中调用父类成员?
- 用super来指代父类对象,调用相应成员
- super和this是对应的
class Dialog{
int w;
int h;
public void show(){
System.out.println("Dialog显示");
}
}
class FontDialog extends Dialog{
String fontName;
public void show(){
super.show();
System.out.println("FontDialog显示");
}
}
class Test{
public static void main (String[] args) {
FontDialog fd = new FontDialog();
fd.show();
}
}
多态性
1、概念
- 多态性:一个事物,在不同情况下呈现出不同形态
- 重载: 一个函数名,在不同参数传入下,实现不同功能
重载属于“静态多态性”;静态体现在:必须为多个函数功能编写相应函数
class Dialog{
public void show(){ System.out.println("Dialog.show"); }
}
class FontDialog extends Dialog{
public void show(){ System.out.println("FontDialog.show"); }
}
class Test{
public static void main (String[] args) {
Dialog d = new FontDialog();
d.show();
}
}
2、动态多态性
- 基本规则:父类引用可以指向子类对象
- 性质:父类引用调用被覆盖的成员时,调用的是子类对象中的成员
两种使用情况
(1)形参定义父类类型,实参可以传入子类对象
FontDialog是Dialog的子类
void fun(Dialog d){ /**/ } 函数定义
fun(new FontDialog); 函数调用
(2)函数返回父类类型,实际返回子类对象
FontDialog是Dialog的子类
Dialog fun(){ 函数定义
return new FontDialog();
}
Dialog d = fun();
d.show(); 函数调用
案例:有FontDialog和ParaDialog两个类,在主界面类中,定义一个函数,可以将对话框在界面中居中。
class Dialog{
public void show(){ System.out.println("Dialog.show"); }
}
class FontDialog extends Dialog{
public void show(){ System.out.println("FontDialog.show"); }
}
class ParaDialog extends Dialog{
public void show(){ System.out.println("ParaDialog.show"); }
}
class MainFrame{
public void toCenter(Dialog d){
/*计算界面坐标*/
d.show();
}
public static void main (String[] args) {
MainFrame mf = new MainFrame();
MyNewDialog mnd = new MyNewDialog();
mf.toCenter(mnd);
}
}
class MyNewDialog extends Dialog{
public void show(){
}
}
案例:编写一个类似Word的软件,窗口上点击菜单,出现一个“字体对话框”。
如果用户想要开发一个新的对话框,怎么办?
class Dialog(){
public void show(){}
}
class FontDialog extends Dialog{
pubilc void show()
{
System.out.println("FontDialog显示");
}
}
class Window{
public void cilckMenu(Dialog d){
d.show();
}
public static void main(String[]args){
Window w = new Window();
w.clickMenu(new MyFontDialog());
}
}
class MyFontDialog extends Dialog{
public void show()
{
System.out.println("自己编写的好看的Dialog就有了")
}
}
多态性体现在:一个父类引用,在不同子类对象被指向的情况下,完成相应子类的功能。
该思想是软件支持“不修改源代码的情况下二次开发”以及“不修改源代码的情况下,模块可拼装”的基础。将两个业务类的关系变远,这叫做软件工程里的“低耦合”。
- 多态性:一个事物,在不同情况下呈现出不同形态
- 重载: 一个函数名,在不同参数传入下,实现不同功能
- 动态多态性:一个函数,在不同子类对象参数传入情况下,实现不同功能
抽象函数:
在函数前面增加abstract关键字,该函数原则上要被重写,否则报错。
- 含有抽象函数的类就叫做抽象类,用abstract修饰
- 抽象函数必须被重写,除非该子类也是一个抽象类
- 抽象函数没有函数体(类似c++里的纯虚函数)
- 抽象类不能被实例化
问题:
1、抽象类中可以有普通函数吗?
可以
2、抽象类中是否可以写构造函数?
不可以
3、抽象类不能被实例化,那它的构造函数和普通函数有什么用?
构造函数可以初始化某些变量,普通函数可以被子类重用
4、抽象函数必须重写吗?
不一定,如果子类也是个抽象函数的话
抽象类、抽象函数是一种:标准化手段
抽象类中可以有普通的函数,抽象类可以拥有一些自己的功能。
再介绍一种比抽象类更抽象的“抽象类”,叫做接口(interfance)
interfance和抽象类类似,只不过它里面所有的内容只能是抽象函数,所有的变量只能是常量。
关于接口:
1、接口中所有变量都是常量,所有函数都是抽象函数,abstract可以省略
2、接口中的所有成员都是public的。public可以省略
3、接口中的任何变量都是常量,并且是静态常量
4、一个类最多只能继承一个抽象类,但可以实现多个接口,逗号隔开
interface Dialog1{
void show1();
}
interface Dialog2{
void show2();
}
class FontDialog implements Dialog1,Dialog2{
public void show1(){
System.out.println("show1显示");
}
public void show2(){
System.out.println(Dialog2.a);
System.out.println("show2显示");
}
}
为什么叫“接口”呢?
起到连接作用,又是候也叫做“界面”。
3、其他内容
final关键字
在类、成员变量和成员函数之前增加final关键字
类前面增加final关键字,则该类不能有子类
在成员函数前增加final,则该函数不能被重写
在成员变量前加final,则该成员变量是常变量,必须提前赋值,不能改变其值
Object类
java中任何一个子类都是Object子类。
该类有两个小作用:
Object类中,有一个toString方法,可以给子类一个以字符串展示的机会。
Objiect类中,有一个equals方法,可以给子类对象一个比较他们是否相等的机会。
两个对象名,a==b,除非a和b指向同一个对象,才返回true
如果自定义两个对象内容相等呢?就可以重写equals方法
class Customer{
String cname;
String password;
String account;
double balance;
public String toString()
{
return account + "-" + cname +"-"+balance;
}
public static void main()
{
Customer zs = new Customer();
System.out.println(zs);
}
}
class Customer{
String account;
double balance;
public boolean equals(Customer c)
{
if(cname.equals(c.cname)&&balance.equals(c.balance))
{
return true;
}
return false;
}
public static void main()
{
Customer zs = new Customer();
zs.cname = "zhangsan";
zs.balance = 1000;
Customer ls = new Customer();
zs.cname = "lisi";
ls.balance = 1000;
}
}
练习:详细讲解多态性的应用
编写一个按钮,具有点击功能,编写一个按钮,上面有一个按钮,点击按钮,让窗口变红。模拟代码即可。
class Button{
ButtonListener bl;
public void bind(ButtonListener bl) {
this.bl=b;
}
public void click() {bl.action();}
}
interface ButtonListener{
public void action();
}
class Window implements ButtonListener{
Button b = new Button();
public void action()
{
this.toRed();
}
public Window()
{
b.bind(this);
}
public void toRed()
{
System.out.println("窗口变红");
}
public static void main (String[] args) {
Window w= new Window();
w.b.click();
}
}