JavaSE笔记07面向对象编程03

面向对象编程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关键字

1. 表示最终的，不可变的

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

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

4. 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.抽象类

1. abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该方法就是抽象类。
2. 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
3. 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
4. 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
5. 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

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.接口

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

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

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

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

注意：

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

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

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

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类来说就是外部类了。

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

注意：

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

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

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);
	}
}