Java 基本数据类型及类、接口、对象

Java基本数据类型

Java基本数据类型可分为三类：基本类型，引用类型，空类型。其中基本类型可以分为布尔类型（boolean(true/false)）和数值类型（整形：byte(1)，short(2)，int(4)，long(8)；浮点型：float(4)，double(8)），引用类型（String），空类型（null），字符型（char(2)），所有的类型均属于java中的类。java类分为两种，自己定义和常用基本数据类型。

Java数组

表示方法：int arr [ ] = new int [3]; int arr [ ] = new int []{a1,a2};

数组排序

Java对象数组声明

Java对象数组（类名称 对象 = new 类名称[ ]{参数1,参数2,...}），定义私有private 类名称 数组名称（private emp [ ] emps）

匿名对象

有名对象：Book ba = new Book("Java",32.1);
匿名对象：new Book("Java",32.1);

包装类

Java设计思想为一切皆对象，而基本数据类型不属于对象，所以提供了包装类。
一、对象型包装类（Object直接子类）：Character、Boolean；
二、数值型包装类（Number直接子类）：Byte、Short、Integer、Flaot、Double、Long，Number是一个抽象类，里面定义了六个方法 intValue()、flaotValue()、shortValue()、doubleValue()、byteValue()、longValue()。

class MyInt{
    private int temp;
    public MyInt(int temp){
        this.temp = temp;
    }
    public int intValue(){
        return this.temp;
    }
}
public class ListNode{
    public static void main(String []args){
        MyInt mi = new MyInt(10);
        int temp = mi.intValue();
        System.out.println(temp*2);
    }
}

String类

一、 String类的两种实例化方式
String str = "Hello" ;String str = new String("Hello");用equals比较并不相等。

抽象类/抽象方法(没有方法体{}，需用abstract定义)

概念
一、抽象类必须有子类（每一个抽象类一定要被子类所继承）；
二、抽象类的子类（子类不是抽象类）必须要覆写抽象类之中的全部抽象方法；
三、抽象类的对象实例化需要依靠子类完成，采用向上转型的方式处理；
四、抽象方法无方法体，无法被调用;
五、一个子类只能继承一个抽象类，属于单继承。

abstract class A{
    public void fun(){
        System.out.println("ARG_IN");
    }
    public abstract void funa();
}
public class Duo{
    public static void main(String []args){
        A a = new A();
        a.fun();
        a.funa();
    }
}
--------------------------------------------------------
Duo.java:9: 错误: A是抽象的; 无法实例化
                A a = new A();
                      ^
1 个错误

基本语法

abstract class A{
    public void fun(){
        System.out.println("ARG_IN");
    }
    public abstract void funa();
}
class B extends A{    //B是A的子类，所以B也是抽象类
    public void funa(){
        System.out.println("x");
    }
}
public class Duo{
    public static void main(String []args){
        A a = new B();  //向上转型
        a.fun();
        a.funa();  //覆写
    }
}

使用限制
一、不能使用final定义，因为abstract定义的类必须有子类，而final定义的类不能有子类；
二、外部类不允许使用static定义，而内部类允许使用static声明；
三、使用static声明的类属于外部类。

abstract class A{
    static abstract class B{    //使用static声明的类属于外部类
        public abstract void fun();
    }
}
class B extends A.B{   //使用static声明的类属于外部类
    public void fun(){
        System.out.println("abstract");
    }
}
public class Duo{
    public static void main(String []args){
        A.B a = new B();
        a.fun();
    }
}

三、任何情况下，如果执行类中的static的时候，都可以在没有对象的时候直接调用，对于抽象类也是一样。

abstract class A{
    public static void fun(){
        System.out.println("abstract");
    }
}

public class Duo{
    public static void main(String []args){
       A.fun();
    }
}
----------------------------------------------------
//去掉static
Duo.java:9: 错误: 无法从静态上下文中引用非静态 方法 fun()
       A.fun();
        ^
1 个错误

四、内部抽象类

abstract class A{
    public abstract void fun();
    private static class B extends A{
        public void fun(){
            System.out.println("x");
        }
    }
    public static A getInstance(){
        return new B();
    }
}
public class Duo{
    public static void main(String [] args){
        A a = A.getInstance();  //上面实例化了对象B
        a.fun();
    }
}

五、模板设计

package practice;

abstract class Actiona7{
    public static final int EAT = 1;
    public static final int SLEEP = 5;
    public static final int WORK = 7;
    public void command(int flag){
        switch(flag){
            case EAT:
            this.eat();
            break;
            case SLEEP:
            this.sleep();
            break;
            case WORK:
            this.work();
            break;
        }
    }
    public abstract void eat();
    public abstract void sleep();
    public abstract void work();
}
class Human extends Actiona7{
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
    public void work(){
        System.out.println("人工作");
    }
}
class Robot extends Actiona7{
    public void eat(){
        System.out.println("机器人吃饭");
    }
    public void sleep(){
        System.out.println();
    }
    public void work(){
        System.out.println("机器人工作");
    }
}
class Pig extends Actiona7{
    public void eat(){
        System.out.println("猪吃饭");
    }
    public void sleep(){
        System.out.println("猪睡觉");
    }
    public void work(){
        System.out.println();
    }
}
public class Duo{
    public static void main(String []args){
        fun(new Human());
        fun(new Pig());
        fun(new Robot());
    }
    public static void fun(Actiona7 act){
            act.command(Actiona7.EAT);
            act.command(Actiona7.SLEEP);
            act.command(Actiona7.WORK);
        }
}

接口

属于一个抽象的类，这个类里面只有抽象方法和全局变量,和抽象类一样，也不能用new实例化对象。
一、接口必须有子类，但此时一个子类可以使用implements实现多个接口；
二、接口的子类（如果不是抽象类），必须要覆写接口中的全部抽象方法；
三、接口的对象可以利用子类对象的向上转型进行实例化操作；
四、子类可以实现多个接口，而却只能继承一个抽象类，接口不能继承抽象类；
五、一个抽象类只可以继承一个抽象类，而一个接口却可以使用使用extends关键字同时继承多个接口；
六、接口內可以定义普通内部类、抽象内部类、内部接口；
七、使用static定义的类属于外部类，使用static定义的接口属于外部接口。

实现接口

interface A{
    public static final String STR = "Hello";
    public abstract void fun();
}
interface B{
    public abstract void get();
}
class X implements A,B{
    public void fun(){
        System.out.println("A");
    }
    public void get(){
        System.out.println("B");
    }
}
public class Duo{
    public static void main(String []args){
        X x = new X();
        A a = x;
        B b = x;
        a.fun();
        b.get();
    }
}

当子类既要继承又要实现接口时，要先继承后接口。

interface A{
    public static final String STR = "Hello";
    public abstract void fun();
}
interface B{
    public abstract void get();
}
abstract class C{
    public abstract void change();
}
class X extends C implements A,B{
    public void fun(){
        System.out.println("A");
    }
    public void get(){
        System.out.println("B");
    }
    public void change(){
        System.out.println("C");
    }
}
public class Duo{
    public static void main(String []args){
        X x = new X();
        A a = x;
        B b = x;
        C c = x;
        a.fun();
        b.get();
        c.change();
    }
}

外部接口

interface A{
    public void funA();
    static interface B{
        public void funB();
    }
}
class X implements A.B{
    public void funB(){}
}

标准定义（定义不同层之间的操作标准）

接口时一个标准，不同类之间通过接口连接实现

interface Usb{   
    public void start();
    public void stop();
}
class Computer{
    public void plugin(Usb usb){
        usb.start();
        usb.stop();
    }
}
class Mp3 implements Usb{
    public void start(){
        System.out.println("Mp3jion");
    }
    public void stop(){
        System.out.println("Mp3nojoin");
    }
}
class U implements Usb{
    public void start(){
        System.out.println("Ujoin");
    }
    public void stop(){
        System.out.println("Unojoin");
    }
}
public class Duo{
    public static void main(String args[]){
        Computer com = new Computer();
        com.plugin(new Mp3());
        com.plugin(new U());
    }
}

Factory工厂设计模式

Factory工厂设计模式
interface Fruits{
    public void eat();
}
class Oranger implements Fruits{
    public void eat(){
        System.out.println("Eat Orange");
    }
}
class Apple implements Fruits{
    public void eat(){
        System.out.println("Eat Apple");
    }
}
class Factory{
    public static Fruits getIstance(String name){
        if("Apple".equals(name)){
            return new Apple();
        }else if("Oranger".equals(name)){
            return new Oranger();
        }else{
            return null;
        }
    }
}
public class Duo{
    public static void main(String []args){
        Fruits f = Factory.getIstance("Apple");
        f.eat();
    }
}

Proxy代理设计模式

Proxy代理设计模式
interface Subject{
    public void make();
}
class Empire implements Subject{
    public void make(){
        System.out.println("ing");
    }
}
class Assistant implements Subject{
    private Subject sub;
    public Assistant(Subject sub){
        this.sub = sub;
    }
    public void prepare(){
        System.out.println("prepare");
    }
    public void make(){
        this.prepare();
        this.sub.make();
        this.destory();
    }
    public void destory(){
        System.out.println("ed");
    }
}
public class Duo{
    public static void main(String []args){
        Subject subj = new Assistant(new Empire());
        subj.make();
    }
}

抽象类和接口的区别

区别                抽象类                      接口
----------------------------------------------------------------
关键字            abstract class             interface
----------------------------------------------------------------
声明          构造方法、普通方法           抽象方法、全局常量
             抽象方法、变量、常量
-----------------------------------------------------------------
子类使用   class 子类 extends 抽象类     class 子类 implement 接口，接口......
----------------------------------------------------------------
 关系       抽象类可以实现多个接口     接口不能继承抽象类，却可以继承多个父接口
--------------------------------------------------------------------
权限     可以使用各种权限               只能使用public权限
-------------------------------------------------------------------
限制    单继承局限                  没有单继承局限
-----------------------------------------------------------------------
子类   抽象类和接口都必须有子类，子类必须要覆写全部的抽象方法
--------------------------------------------------------------------------
实例化对象     依靠子类对象的向上转型进行对象的实例化

Object类

Object是所有类的父类，在其他类不使用extens时;所有类对象实例化的时候，子类构造一定会默认调用父类的无参构造。
任何一个Java简单类都应覆写Object类中的以下三个方法。

取得对象信息    public String to String();
对象比较    public boolean equals(Object obj);
取得对象HASH码   public int hashCode();

class Book extends Object{
    
}
public class Duo{
    public static void main(String []args){
        Object oba = new Book();
        Object obb = "hello";
        Book ba = (Book)oba;
        Book bb = (Book)obb;
    }
}

取得对象信息 public String to String();

class Book extends Object{
}
public class Duo{
    public static void main(String []args){
        Book bk = new Book();
        String str = "Hello";
        System.out.println(bk);
        System.out.println(bk.toString());
        System.out.println(str);
    }
}
---------------------------------------------------
F:\prac>java Duo
Book@15db9742
Book@15db9742
Hello
-------------------------------------------------------
class Book extends Object{
    private String title ;
    private double price ;
    public Book(String title,double price){
        this.title = title;
        this.price = price;
    }
    public String toString(){
        return "Title:"+this.title+" "+"Price:"+this.price;
    }
}
public class Duo{
    public static void main(String []args){
        Book b = new Book("Java",78.9);
        System.out.println(b);
    }
}
--------------------------------------------------
F:\prac>java Duo
Title:Java Price:78.9

对象比较 public boolean equals(Object obj);

class Book{
    private String title ;
    private double price ;
    public Book(String title,double price){
        this.title = title;
        this.price = price;
    }
    public boolean equals(Object obj){
        if(this == obj){    //地址相同
            return true;
        }
        if(obj == null){
            return false;
        }
        if(!(obj instanceof Book)){    //异常处理，不是本类对象
            return false;
        }
        Book book = (Book)obj;
        if(this.title.equals(book.title)
            && this.price == book.price){
            return true;
        }
        return false;
    }
    
    public String toString(){
        return "Title:"+this.title+" "+"Price:"+this.price;
    }
}
public class Duo{
    public static void main(String []args){
        Book b1 = new Book("Java",78.9);
        Book b2 = new Book("Java",78.9);
        System.out.println(b1.equals(b2));
    }
}

Object可以接收一切引用数据类型
一、Object接收数组对象

public class Duo{
    public static void main(String []args){
        Object obj = new int []{1,2,3};
        System.out.println(obj);
        if(obj instanceof int []){
            int data[] = (int []) obj;
            for(int x=0;x<data.length;x++){
                System.out.println(data[x]);
            }
        }
    }
}

二、Object接收接口对象

interface Book{
    public void fun();
}
class Bk implements Book{
    public void fun(){
        System.out.println("Hello World!!!");
    }
}
public class Duo{
    public static void main(String args[]){
        Book b = new Bk();
        Object obj = b;
        Bk c = (Bk) obj;
        c.fun();
    }
}

三、Object接收接口链表

匿名内部类

使用接口的前提，可以要基于接口或抽象类的应用。

interface Book{
    public void fun();
}
class Text implements Book{
    public void fun(){
        System.out.println("Hello World");
    }
}
public class ListNode{
    public static void main(String []args){
        print(new Text());
    }
    public static void print(Book bk){
            bk.fun();
        }
}

转换

interface Book{
    public void fun();
}
public class ListNode{
    public static void main(String []args){
        print(new Text(){
            public void fun(){
        System.out.println("Hello World");
        }
        });
    }
    public static void print(Book bk){
            bk.fun();
        }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 157,012评论 4赞 359
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,589评论 1赞 290
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 106,819评论 0赞 237
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,652评论 0赞 202
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 51,954评论 3赞 285
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,381评论 1赞 210
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,687评论 2赞 310
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,404评论 0赞 194
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,082评论 1赞 238
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,355评论 2赞 241
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,880评论 1赞 255
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,249评论 2赞 250
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,864评论 3赞 232
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,007评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,760评论 0赞 192
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,394评论 2赞 269
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,281评论 2赞 259

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,292评论 18赞 399
  • JAVA面试题 java部分
    （一）Java部分 1、列举出JAVA中6个比较常用的包【天威诚信面试题】 【参考答案】 java.lang;ja...
    独云阅读 6,928评论 0赞 62
  • Java基础知识总结
    一：java概述：1，JDK：Java Development Kit，java的开发和运行环境，java的开发工...
    ZaneInTheSun阅读 2,582评论 0赞 11
  • 女人吃什么补血最快，皮肤嫩，衰老慢？
    大多女性存在两种问题：一个是血气不足，自然流通不畅，而另一个则是血气凝结，堵塞了，所以也走的不畅快。 多数人谈到补...
    库鲁米阅读 407评论 0赞 0
  • 有一天你会来
    我想有一天你一定会来， 不慌不忙， 却又匆匆闯入我的生活。 陪我看过北方的冬天， 吹过南方的风。 陪我走过古城的小...
    十七姑娘阅读 276评论 0赞 1