面向对象编程03

1.static关键字补充

package com.oop.demo07; public class Student { private static int age;//静态的变量 private double score;//非静态的变量 public void run(){ } public static void go(){ } public static void main(String[] args) { Student s1 = new Student(); System.out.println(Student.age); //System.out.println(Student.score);报错 System.out.println(s1.age); System.out.println(s1.score); s1.run(); s1.go(); Student.go(); go(); //run();报错 //Studnet.run();报错 } } package com.oop.demo07; //静态导入包 import static java.lang.Math.random; public class Test { public static void main(String[] args) { System.out.println(Math.random()); //静态导入包后如下 System.out.println(random()); } }

2.final关键字

表示最终的，不可变的

final修饰的局部变量，一旦赋值就不能重新赋值

final修饰的方法无法被覆盖，无法被重写

final修饰的类无法继承

Public class Test{ Public static void main(String[] args){ //局部变量 int i = 100; i = 200; final int k = 100; k = 300; //错误，无法为最终变量k分配值 final int m; m = 200; m = 300; //重新赋值：错误，可能已分配变量m } } //如果不希望B类继承A类，可以给A类加final关键字 final class A{…}//A没有子孙 class B extends A{…}//错误，无法从最终A进行继承 class C{ public final void doSome(){ System.out.println(“C’s doSome…”); } } Class D extends C{ Public void doSome(){ System.out.println(“D’s doSome…”); }//错误，D中的doSome()无法覆盖C中的doSome() }

注意：一般实例变量若没有手动赋值，系统会默认赋值，但如果加了final，系统就不负责付默认值，要求程序员必须手动赋值

public class Test{ public static void main(String[] args){ } } class User{ //实例变量 final int age;//错误 final double height = 1.8; final double weight; //构造方法 public User(){ this.weight = 80; } }

3.抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该方法就是抽象类。抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类抽象类，不能使用new关键字来创建对象，它是用来让子类继承的抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类 package com.oop.demo08; public class Application { public static void main(String[] args) { //Action a = new Action();报错 } } package com.oop.demo08; //abstract 抽象类 类 extends：单继承（接口可以多继承） public abstract class Action { //abstract,抽象方法，只有名字，没有方法的实现！ public abstract void doSomething(); /* 1.不能new这个抽象类，只能靠子类去实现它：约束！ 2.抽象类中可以写普通方法 3.抽象方法必须要在抽象类中 */ } package com.oop.demo08; //抽象类的所有方法，继承了它的类，都必须要实现它的方法 public class A extends Action { @Override public void doSomething() { System.out.println("doSomething"); } }

4.接口

普通类：只有具体实现抽象类：具体实现和规范（抽象方法）都有接口：只有规范

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑…

OO的精髓，是对对象的抽象，最能体现这一点的就是接口

声明类的关键字是class，声明接口的关键字是interface

注意：

接口中只有常量和抽象方法，没有其他内容

接口中所有元素都是public修饰的（都是公开的）

接口不能被实例化，接口中没有构造方法

package com.oop.demo09; //类可以实现接口，implements 接口 //实现了接口的类，就需要重写接口中的方法 //利用接口实现多继承 public class UserServiceImpl implements UserService,TimeService{ @Override public void add(String name) {} @Override public void delete(String name) {} @Override public void update(String name) {} @Override public void query(String name) {} @Override public void timer() {} } package com.oop.demo09; //抽象的思维 //定义的关键字interface，接口都需要有实现类 public interface UserService { //public void run(){}报错 //接口中的所有定义其实都是抽象的 public abstract //可以省略public 前面的 public abstract //public abstract add(); void add(String name); void delete(String name); void update(String name); void query(String name); //常量 //public static final int AGE = 99; int AGE = 99; } package com.oop.demo09; public interface TimeService { void timer(); }

例子

Public class Test{ Public static void main(String[] args){ //同一个接口，调用同一个fly()方法，最后的执行结果不同 Flyable f = new Cat(); f.fly(); Flyable f2 = new Fish(); f2.fly(); } } class Animal{…}//动物类，父类 //接口，可飞翔的接口（是一对翅膀） interface Flyable{ Void fly(); } //Flyable是一个接口，通过接口插到猫身上，让猫可以飞翔 Class Cat extends Animal implements Flyable{//子类，猫类 Public void fly(){ System.out.println("猫咪起飞~"); } } //子类，蛇类，不想让她飞，可以不实现Flyable接口 Class Snake extends Animal{}

5.内部类(了解)

内部类就是在一个类的内部再定义一个类，比如，A类中定义了一个B类，那么B类相对于A类来说就成为内部类，而A类相对于B类来说就是外部类了。

成员内部类静态内部类局部内部类匿名内部类

注意：

使用内部类编写的代码，可读性差，能不用尽量不用

匿名内部类是局部内部类的一种，因为没有名字而得名匿名内部类

Class Test{ //由于前面有static，所以称为静态内部类 static class Inner1{} //没有static叫做实例内部类 Class Inner2{} Pulic void doSome(){ //局部变量 int i = 100; //局部内部类 Class Inner3{} } Public void doOther(){ //doSome()方法中的局部内部类Inner3在doOther()中不能用 } Public static void main(String[] args){ MyTime mm = new MyMath(); //匿名内部类，后面的{}代表了对接口的实现 mm.mysum(new Compute(){ public int sum(int a,int b){ return a + b; } },100,200) } } //负责计算的接口 interface Compute{ //抽象方法 int sum(int a,int b); } Class MyMath{ //求和方法 Public void mysum(Compte c,int x,int y){ int revalue = c.sum(x,y); System.out.println(x + “+” + y + “=” + retValue); } }