java桌面 第三章包 接口 抽象类

1. 3. package org.lgc;
   5. public class 滑翔机 extends 飞机 {
   6.     public 滑翔机(){
   7.         super("滑翔机");
   8.     }
   9.     
   10.     public void 起飞(){
   11.         System.out.println(this.type+"在跑道上起飞");
   12.     }
   13.     
   14.     public void 降落(){
   15.         System.out.println(this.type+"在跑道上降落");
   16.     }
   17.     
   18.     
   19. }
   4. package org.lgc;
   6. public class 直升机 extends 飞机{
   7.     public 直升机(){
   8.         super("直升机");
   9.     }
   11.     public void 起飞() {
   12.         System.out.println(this.type+"垂直起飞");
   13.     }
   15.     public void 降落() {
   16.         System.out.println(this.type+"垂直降落");
   17.     }
   18.     
   19.     
   20. }
   5. package org.lgc;
   7. public class Test {
   8.     public static void main(String[] args) {
   9.         飞机 p = new 滑翔机();
   10.         p.起飞();
   11.         p.降落();
   12.         p.载人();
   13.         p.载物();
   14.         System.out.println("******************");
   15.         p = new 直升机();
   16.         p.起飞();
   17.         p.降落();
   18.         p.载人();
   19.         p.载物();
   20.     }
   21. }
   package org.lgc;
3. public interface 飞机功能 {
4.     //所有方法前面默认都有public abstract
5.     void 载人();
6.     void 载物();
7.     void 起飞();
8.     void 降落();
9. }

 

2. package org.lgc;
4. public abstract class 飞机 implements 飞机功能 {
5.     String type;//飞机类型
6.     
7.     public 飞机(String type){
8.         this.type = type;
9.     }
10.     
11.     public void 载人(){
12.         System.out.println(this.type+"可以载人！");
13.         
14.     }
15.     
16.     public void 载物(){
17.         System.out.println(this.type+"可以载物！");
18.     }
19.     
20. }

第三章

一．static关键字

       1.修饰方法。

a)被static修饰的方法称之为静态方法。它是属于类的，通过类名来访问，不建议使用对象来访问。

b)静态的方法不能访问非静态的属性和方法。但非静态的方法可以访问静态的成员。

2.修饰属性。

a)通过类名来访问。不建议使用对象访问。

b)静态的属性是属于类的。

c)静态的属性一出来就有默认值了。而非静态的属性是在创建对象时才有默认值的．

       3.修饰类

a)static可以修饰内部类．

二．final关键字

       1．修饰属性

              a)被final修饰的属性为常量．不能二次赋值．

              b)规范：一般常都会声明为public static final的．名字全部使用大写字母

       2.　修饰方法

              a)可以重载．不能重写

       3.　修饰类(最终类)

              a)被final修饰的类不能被继承．典型的类：String，Math

三．打包package和导包import

       1.打包package：解决类重命的问题．是一个习惯．必须写在第一句

       包命名：网站www.xdsvse.com，包命名是一个反的：com.xdsvse．org.lgc．org.hsl

       2.导包import：导入其它位置的类到当前．系统会默认的帮我们导入java.lang包

       可以写多句，写在类外

       编写java文件的顺序：package -> import ->class

四．访问修饰符

      

关键字	本类	同包子类	同包它类	包外子类	包外它类
private私有	是	否	否	否	否
默认	是	是	是	否	否
protected受保护	是	是	是	是	否
public 公有	是	是	是	是	是

 注意：只有默认和public能够修饰类。被public修饰的类必须和文件同名

 

面向对象回顾：

1.       封装

a)         将属性和方法写在类中

b)        属性应该都是私有(private)，是通过公有(public)的get和set方法来访问和赋值。

2.       继承

a)         Java中的继承：单继承。

b)        继承时子类会继承父类所有的属性和方法

c)         私有的属性和方法会被继承，但不能使用

d)        构造方法不能被继承

e)         子类的构造方法中默认都会有一句super( )

3.       多态

a)         重载：同一个类中有多个方法名字一样，但参数的个数或参数的数据类型不一致。

b)        重写：子类中有方法和父类的方法一样。

c)         父类的引用存放子类的对象：

                                      i.              能访问父类：所有属性，没有被重写的方法

                                    ii.              能访问子类：只能访问重写父类的方法。

一．抽象类(abstract)

a)         修饰类：抽象类可以写得跟一般的类一模一样。

b)        修饰方法：抽象方法，不能有方法体的。(直接将一对{ }大括号换成;分号)

c)         抽象类中可以没有抽象方法，但抽象方法必须写在抽象类中。

d)        抽象类不能被实例化。但可以写构造方法。

e)         子类必须重写抽象类中的所有抽象方法。(注意：重写时访问修饰必须>=父类方法的访问修饰)。

反之：如果一个类继承了抽象类，而又没有重写抽象方法，且程序正确。那么这个类一定是抽象类。

f)         应用：如果多个类有相同的方法且做一样的事情，也有相同的方法，但做的事情不一样，此时我们将写一个抽象类，把做一样事情的方法写在抽象类中，把做不一样事情的方法写成抽象方法。

二．接口(interface)：为了弥补Java单继承的不足。

a)         类不能继承接口，而是实现接口。使用implements关键字

b)        类可以实现多个接口

c)         接口中所有的属性都是public static final

d)        接口中所有的方法都是public abstract

e)         一个类实现了接口，必须重写接口中的所有方法。

反之：如果一个类实现了接口，而又没有重写抽象方法，且程序正确。那么这个类一定是抽象类。

 

f)         应用：将多个类都有的方法全部写在接口中。

 

接口和抽象类结合应用：

1.       将多个类中都有的方法全部写到接口中

2.       将多个类中相同的方法写到抽象类中，由抽象类来实现接口。

3.       由子类来继承抽象类。