Java 基本数据类型及类、接口、对象
2017-02-23 本文已影响70人
嘉美伯爵
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();
}
}
