继承、接口、抽象方法

Runtime类

public class Demo3 {
    public static void main(String[] args) {
        //Runtime:运行时
        //每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
        //可以通过 getRuntime 方法获取当前运行时。 

        //应用程序不能创建自己的 Runtime 类实例。

        //获取运行时对象
        Runtime runtime = Runtime.getRuntime();
        //获取的单位是字节
        System.out.println(runtime.totalMemory()/1024./1024);//我们使用的总内容量
        System.out.println(runtime.maxMemory()/1024./1024);//可以使用的最大内存量
        System.out.println(runtime.freeMemory()/1024./1024);//当前空余的内存量
    }
}

final关键字
package com.qianfeng.test;

public class Demo4 {
    /*
     * final:最终的,不可改变的.
     * 可以修饰的内容:
     * 1.类:不能有子类
     * 2.成员方法:不能重写
     * 3.成员变量:他的值是不能变了,成员变量必须先给一个值,并且值不能再改变
     * 4.局部变量:他的值是不能变了,变成一个定值.
     */
}

 class FuTest{
    final int age = 10;//final修饰的成员变量必须先给一个值,并且值不能再改变
    public  void test(){
        //age = 12;
        final int height;
        height = 3;
        //height = 4;//当给定一个值之后,不能再改变值.
    }
}

class ZiTest extends FuTest{
    //final修饰的成员变量不能重写
//    public void test() {
//        // TODO Auto-generated method stub
//        super.test();
//    }
}



public class Demo5 {
    //求圆的面积
    public static void main(String[] args) {
        Circle circle = new Circle(2);
        double area = circle.getArea();
        System.out.println(area);
    }
}
class Circle{
    double r;
    final double PI = 3.14;//定值--符号常量
    
    public Circle(double r) {
        super();
        this.r = r;
    }

    public double getArea(){
        return PI*r*r;
    }
}

//单例中的饿汉式
class SingleInstance{
    private static final SingleInstance singleInstance =   new SingleInstance();
    private SingleInstance(){
        
    }
    public static SingleInstance getInstance() {
        return singleInstance;
    }
}

抽象类和方法


public class Demo6 {
    public static void main(String[] args) {
        /*
         * 方法的声明:没有方法体的方法
         * 
         * abstract:抽象的
         * 可以修饰的内容:
         * 1.方法:抽象方法
         * 2.类:抽象类
         * 抽象类:在继承中,提取父类方法的时候,每个子类都有自己的具体实现方法,父类不能决定他们
         * 各自的实现方法,父类就不管了.所以在父类中只写方法的声明,将方法的实现交给子类.在类中
         * 只有方法声明的方法称为抽象方法,拥有抽象方法的类称为抽象类.
         * 
         * 注意点:
         * 1.抽象类不一定有抽象方法,但是有抽象方法的一定是抽象类.
         * 2.继承了抽象类的子类一定要实现抽象方法,如果不实现就只能将自己也变成抽象的.
         * 3.抽象类不能直接创建对象,必须通过子类实现,所以抽象类一定有子类
         * 
         * 比较普通类与抽象类:
         * 1.普通类可以直接创建对象
         * 2.抽象类可以有抽象方法
         * 
         * 不能与abstract同时存在的关键字
         * 1.final:被final修饰的类不能有子类,方法不能重写,但是abstract必须有子类,必须重写
         * 2.static:修饰的方法可以通过类名调用,abstract必须通过子类实现
         * 3.private:修饰的方法不能重写,abstract必须重写
         */
        //抽象类不能直接创建对象
        //Person person = new Person();
    }
}

//抽象类--拥有抽象方法的类一定是抽象类
abstract class Person{
    String name;
    //抽象方法---相当于指定了一个规则
    public abstract void teach();
}

//可以将子类变成抽象的,之后要想使用当前的类就必须再创建子类,因为抽象类不能直接创建对象.
class Teacher extends Person{
    //重写--写抽象方法的实现
    public void teach() {
        
        
    }
}

代码案例

public class Demo7 {
    public static void main(String[] args) {
        /*
         * 求圆和矩形的面积
         */
        //测试:
    }
}

abstract class Shape{
    public abstract  double getArea();
}

class Circle1 extends Shape{
    double r;
    final double  PI = 3.14;
    
    public Circle1(double r) {
        super();
        this.r = r;
    }

    public double getArea() {
        
        return PI*r*r;
    }
}

class Rectangle extends Shape{
    double height;
    double width;
    
    public Rectangle(double height, double width) {
        super();
        this.height = height;
        this.width = width;
    }

    public double getArea() {
        return height*width;
    }
}

接口
/*
 * 接口:interface
 * 构成:
 * interface 接口名字{
 *         接口的实现部分
 *         (默认是public static final)成员变量;
 *         (默认是public abstract)成员方法;
 * }
 * 
 * 一般接口中不写成员变量,只写方法--只写规则---方法列表
 * 
 * 接口起作用的方式:让类去实现接口
 * 类与类之间的关系--继承---extends
 * 类与接口之间的关系---实现----implements
 * 
 * 问题一:接口与父类可以同时存在吗?
 * 答:可以
 * 
 * 问题二:一个子类只能有一个父类,也只能有一个父接口吗?
 * 答:不对,可以同时存在多个接口.
 * 
 * 问题三:父类与接口的功能如何分配?
 * 答:一般父类中放的是主要功能,接口中放的是额外的功能.接口作为父类的补充
 * 
 * 问题四:接口可以直接创建对象吗?
 * 答:不可以,因为接口默认是抽象的
 * 
 * 问题五:接口与接口之间可以有关系吗?如果有,是什么关系?
 * 答:可以有,是多继承的关系.
 * 
 * 问题六:当一个类实现的接口中出现了相同的方法,子类中实现方法的时候会不会混淆?
 * 答:不会,接口中的方法都是抽象的,要通过子类写具体的实现.我们在调用方法的时候,最终看的功能,而功能只有一份.
 * 
 * 接口功能总结:让java从单继承间接的实现了多继承.扩充了原来的功能.
 * 
 * 了解:
 * 从jdk1.7之后,接口中可以有方法的实现,但是方法必须是被static或者default修饰的.
 */

interface Inter1{
    int age = 3;//默认前面是public static final,所以成员变量必须先给一个值
    public void play();//默认就是抽象的
}

interface Inter2{
    public void show();
}

//接口Inter3同时继承了两个接口
interface Inter3 extends Inter1,Inter2{
    
}

//这里是继承了Object类,同时实现了两个接口,接口之间用,隔开
class Dog extends Object implements Inter1,Inter2{
    
    public void play() {

    }

    public void show() {
        // TODO Auto-generated method stub
        
    }
}

package com.qianfeng.test;

public class Demo8interface {
    //1.在jdk1.7的接口中可以写方法的实现,方法必须是default或static的
    //2.接口还是不能直接创建对象,要通过子类
    /*
     * 接口的子类重写方法注意事项
     * 如果一个类实现两个接口，这两个接口同时有相同的抽象方法，在类中只需要重写一次这个方法。 
    如果接口中有default修饰的方法不需要重写。 
    如果两个接口里的方法名相同都是default方法，里面的方法体不同，在类中需要重写该方法。 
    如果两个接口中方法名，参数都相同的方法，一个接口是抽象方法，另一个是default修饰有方法体。这时该类也必须重写该方法。
     */
    public static void main(String[] args) {
        //一个类有一个接口的情况
        
//        //讲解Test6
//        Test6 test1 = new Test6();
//        test1.run();
//        test1.eat();//调用父类的defalut方法,可以通过子类的引用调用
//        //接口中static类型的方法,必须使用当前方法所在的接口名字去调用
//        inter5.bark();
        
        
        
        //一个类有两个接口的情况
        
        Test5 test = new Test5();
        test.run();
        //两个接口的同名方法,两个都是default类型的
        test.eat();
        
        //子类的静态方法可以与父类的相同,但是方法在调用的使用各自调用各自的
        inter5.bark();
        //如果两个接口中只有一个有default方法,不需要重写,可以直接使用
        test.song();

        Test5.bark();
        
        //两个接口中的同名方法,一个是default类型的(有实现),一个是抽象的
        test.play();
    }
}

interface inter5{
    public void run();
    
    default public void song() {
        System.out.println("song");
    }
    default public void eat(){
        System.out.println("default");
    }
    
    static public void bark(){
        System.out.println("static");
    }
    
    default public void play() {
        System.out.println("play");
    }
}

interface inter6{
    public void run();
    default public void eat(){
        System.out.println("default1");
    }
    
    static public void bark(){
        System.out.println("static1");
    }
    
    public void play();
}

class Test6 implements inter5{


    //
    public void run() {
        System.out.println("Test6");
        
        
    }
    
    //default只能放在接口中
        //如果当前接口中有一个default方法,不需要重写,可以直接使用
    //比如现在的eat方法
    
    //子类的静态方法可以与父类的相同,但是方法在调用的时候各自调用各自的
    static public void bark(){
        
        System.out.println("static");
    }
    
}

class Test5 implements inter5,inter6{

    //如果两个接口中有相同的抽象方法,只需要重写一次
    public void run() {
        System.out.println("run");
        
    }
    
    
    
    
    //如果两个接口中有相同的都有default实现的方法,我们必须要重写
    //在重写方法中可以同时对两个父接口的调用,也可以只调用其中一个
     public void eat() {
        // TODO Auto-generated method stub
        inter6.super.eat();//调用inter1中的方法
        inter5.super.eat();//调用inter中的方法
        
        //再写自己的功能
        System.out.println("Test-eat");
    }

    //如果两个接口中有两个同名的方法,一个是default实现的方法,一个是抽象方法,我们必须要重写
    //在重写方法中可以同时对两个父接口的调用,也可以调用一个
    public void play() {
        inter5.super.play();
        System.out.println("");
    }


    //子类的静态方法可以与父类的相同,但是方法在调用的时候各自调用各自的
    static public void bark(){
        
        System.out.println("substatic");
    }
    
}

package com.qianfeng.test;

public class Demo9 {
    /*
     * 实例:防暴犬,搜救犬,导盲犬都去工作,中间还有一个导盲驴也要干活儿,导盲犬和导盲驴都要学习导盲技术
     * 
     * 抽象类,抽象方法,接口,继承
     */
}

abstract class 犬{
    public abstract void work();
}

class 防暴犬 extends 犬{
    
    public void work() {
        System.out.println("防爆");
        
    }
}

class 搜救犬 extends 犬{
    
    public void work() {
        System.out.println("搜救");
        
    }
}

interface Inter{
    public void study();
}

class 导盲犬 extends 犬 implements Inter{ 
    @Override
    public void work() {
        System.out.println("导盲");
        
    }
    
    @Override
    public void study() {
        System.out.println("学习导盲技术");
        
    }
}

class 导盲驴  implements Inter{
    @Override
    public void study() {
        System.out.println("学习导盲技术");
        
    }
}

package com.qianfeng.test;
/*
 * Object类:
 */
public class Demo10 {
    /*
     * 实例:根据轮子的个数比较两辆车
     */
    public static void main(String[] args) {
        Car car1 = new Car(3);
        Car car2 = new Car(4);
        boolean b = car1.comWithWheels(car2);
        System.out.println(b);
        //默认的equals方法的比较规则是比较两个对象的地址
        //我们可以通过重写equals方法达到自己指定规则的目的.
        boolean b1 = car1.equals(car2);
        System.out.println(b1);
        
        //hashCode()获取是当前对象的哈希码值--直接拿到的是十进制的
        System.out.println(car1.hashCode());//31168322
        System.out.println(car2.hashCode());//17225372
        
        //得到十六进制的数
        System.out.println(Integer.toHexString(car1.hashCode()));//1db9742
        
        //toString(),默认打印的是包名+类名+@+十六进制的哈希值
        System.out.println(car1.toString());//com.qianfeng.test.Car@1db9742
        System.out.println(car1);//默认执行的是toString()
        
        //了解:
        //getClass():获取的是当前对象的字节码文件
        //字节码文件:一个类只有一个
        //字节码文件本身就是一个对象
        //字节码文件对象对应的类是Class
        Class class1 = car1.getClass();
        System.out.println(class1);//字节码文件对象  class com.qianfeng.test.Car
        //拼成默认的toString
        System.out.println(class1.getName()+"@"+Integer.toHexString(car1.hashCode()));//com.qianfeng.test.Car@1db9742
    }
}

class Car{
    int wheels;
    public Car(int wheels) {
        super();
        this.wheels = wheels;
    }
    public boolean comWithWheels(Car car){
        return wheels>car.wheels;
    }
    
    //重写equals方法,自己制定比较规则
    public boolean equals(Object obj) {//多态  obj = new Car(4) ,就是用父类的引用指向子类的对象.
        //向下转型-多态中的知识,从高类型转成低类型
        Car car = (Car)obj; //car = new Car(4)
        return wheels<car.wheels;
    }
    
    //重写toString---目的:可以更加方便的查看当前对象的属性信息
    public String toString() {
        return "Car [wheels=" + wheels + "]";
    }
    
    
    
}