疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

java基础(面向对象)


 

   

  面向对象是一种以事物为中心的编程思想,把构成问题事物分解成各个对象,描述某个事物在整个解决问题的步骤中的行为。

  一.创建对象,变量,类中的方法,构造器

  对象的类型 对象名=new 类的方法();Animal animal=new Animal();

  变量是java程序的一个基本存储单位,也就是说,在java中要存储一个数据,必须将它容纳在一个变量之中。

  方法:用来定义类的某种行为,很多时候被称为:成员方法。很多时候我们把执行的算法等放入方法中,这个过程是方法的定义。

  方法的格式:Public void way([参数列表]){方法内容}----->访问修饰符 返回值类型 方法名([参数列表]){方法内容};

  构造器:对对象进行初始化。例:public 类名(){};由此可见,构造器没有返回值,也不能被继承。

  构造器的例1:public class Animal(){ 构造器例2:public class Animal(){ ------->主函数类中 public static void main(String[] arg){

  int eyes; int eyes;

  int foot; int foot; } Animal animal()=new Animal(2,4);

  //在此处创建对象,写初始化值

  public Animal(){ public Animal(int eyes,int foot){

  eyes=2; this.eyes=eyes;

  foot=4; this.foot=foot;

  } System.out.println(eyes+" "+foot)}

  }

  以上两种例子所表达的主意图都是一样的,初始化属性,定义属性的初始化值。第一种方法是直接初始化值,而第二种是传参数进行修改初始化值。构造器中的括号里就是参数。一个类中可以有多个构造器(构造器的重载),区别这些构造器的方法就是构造其中的数据类型,个数的不同,几个构造器的数据类型相同,那么构造器中的数据个数就不能一样,或者是类型各不相同。在构造其中的数据的类型顺序是什么,在创建的对象中就应该传怎样顺序的数据去填写。

 

  二.访问修饰符,类的封装

  访问修饰符一般有:public,protected,private,无修饰符。

  public:对外公开

  protected:向子类和同一包中的类公开

  private:私有,完全不公开。

  无修饰符:向同一包中的类公开。

  封装就是隐藏实现细节,将它private。

  例:public class Animal(){ --->在主函数中访问私有属性:Animal animal=new Animal();

  private int eyes; animal.setEyes(2);

  public int getEyes(int eyes){int animal=getEyes();

  //通过setter,getter方法访问eyes属性

  return eyes;

  }

  public void setEyes()[

  this.eyes=eyes;//this代表当前类的实例

  }

  }

  封装的实现:修改属性的可见性来实现对属性的访问。为这些属性添加setter(赋值)和getter(取值),来对这些属性进行访问。在set和get中编写这些属性的存取限制。在主函数中创建对象之后用set对属性进行赋值。用get进行取值。

  修饰符:abstract(抽象)可以修饰:类,成员方法(方法)。使用abstract修饰类表示此类为抽象类,抽象类不能被实例化(不能产生对象)。抽象方法没有方法体。抽象类可以没有抽象方法,但是有抽象方法,那么这个类一定被定义为抽象类。没有抽象构造方法,抽象类的构造器是正常的。抽象类可以含有具体方法。

  final(终态):可以修饰非抽象类,非抽象方法和变量。被final修饰的类,将不能被继承。被final修饰的方法, 将不能被子类重写。final修饰的变量必须赋值,并且不能再改变,也就是常量。final方法不能被重写,不能被继承。

  static(静态):可以修饰成员变量和成员方法,代码块。被静态修饰的属性,方法和代码块不再属于某个对象,将可以直接使用类名/方法名/属性名(),这样来进行调用。使用static,在jvm虚拟机加载该类的时候调用该static修饰的部分,调用得很早(比构造器早)。被statix修饰的变量将在整个程序中只有一份,被statix修饰的方法并不需要通过所属类的实例(对象)来调用。所以在静态方法中不能使用this,也不能访问此类的非静态方法和非静态变量。

  三.继承

  在已有类的基础上定义新的类。而不需要把已有类的内容重新写一遍,这就叫做继承。已有的类称为父类,在此基础上建立的新类称为子类。

  继承语法:public class Child extends father(){

  成员列表

  }

  子类继承父类之后,就可以继承父类的public变量,方法。子类也可以定义自己的属性和方法,也可以重写父类的方法。在java中所有类都间接或直接的在Object类。并且Java中只支持单继承。子类继承父类的方法,想要对这个方法做修改,我们就需要对这个方法进行重写。如果子类方法与父类中的某一方法具有相同的方法名,返回类型和参数表,新方法将覆盖原有的方法,如果需要父类中原有的方法,就使用super字来引用当前类的父类。子类函数的访问权不能比父类的小。

  public void work(){//父类中的work方法 ----子类-->public void work(){

  System.out.println("我在工作"); String msg=this.getName+"在工作"; }

  }

  this表示活动对象本身,任何一个活动对象对象都有一个默认的this指针指向自己。

  格式:this.成员变量名; this.成员方法名;this();

  表示当前活动对象的直接父类对象:super.成员变量名; super.成员方法名; super([参数]);在静态方法中不能使用this和super。

  多态:体现在继承过程中,子类和父类类型的互相转换,子类对象直接赋值给一个父类的引用变量,被称为向上转换,父类转为子类需要强制转换。

  Person p=new Student();p.work();//子类引用父类的重写方法。p.eat();//eat()为子类方法,无法引用子类独有的方法。子类转换为父类:引用变量名=new 子类型();调用得方法是子类重写或继承父类的方法。无法调用子类特有的方法。父类转子类:引用变量 =new 父类类型();

  四.接口

  接口:只有抽象方法的抽象类。

  格式1:接口的类型interface 接口名{

  常量(必须初始化);

  成员方法定义(只有原形而无函数定义体)

  }

  例:public interface Person{//接口

  int a=5;

  void eat();

  }

  public class Student implements Person{

  public void eat(){}

  }

  接口的实现:class 类名 implements 接口名1,接口名2...一个类可以使用implements,从而实现多继承的机制。

  实现接口的类必须实现接口中的所有方法,否则视为抽象类。被实现的接口方法必须使用pulic权限,因为接口中的方法权限应该比实现方法的类高。接口与接口使用extends,子类实现用implements。

  默认常量:public static final和public abstract。

  类只能继承一个类,对于接口,可以实现继承多个接口。

  五.内部类

  内部类:定在一个类,内部定义的类。内部类分以下几种:成员内部类,局部内部类,匿名内部类。通过内部类可以访问外部类的所有私有成员。

  成员内部类:定义在类的内部,与成员变量与方法在同一层。

  class OutClass{

  class InnerClass{

  public void mTest(){}

  }

  }

  使用这个内部类,获取成员内部类:OutClass.InnerClass inner=new OutClass().new InnerClass;外部类.内部类 对象名=new 外部类().new 内部类名;

  注意:成员内部类可以直接访问外部类的所有成员。成员内部类中还能拥有自己的成员内部类,最里面的成员内部类可以访问所有外部类的成员。外部类不能直接访问内部类的成员,必须创建内部类的对象。内部类中不能定义静态变量和静态方法。在内部类中如有与外部类有相同的变量,需要使用:外部类名.this.变量名。这样来访问。

  外部类只能使用public和default两种访问控制符。内部类和方法,属性在同一层,可以使用:public,protected,private,(default)默认即不写。

  静态内部类:用static修饰内部类。

  例:Class OutClass{

  static class InnerClass{

  }

  }

  创建静态内部类的对象:OutterClas.InnerClass inner=new OutterClass.InnerClass();

  注意:静态内部类可以直接访问外部类的静态成员。(注意是静态成员)静态内部类中可以有静态成员也可以有实例成员。静态内部类中的静态成员可以使用这种方式调用:外部类名.内部类名.静态成员。

  局部内部类:public void way(){

  class InnerClass{

  public void test(){}

  }

  new InnerClass().test();

  }

  由上可见该局部内部类是定义在一个方法中,所以该局部内部类只能在定义的方法内使用。局部内部类不能包含静态成员,局部内部类必须在定义后使用。局部内部类与局部变量一样不能使用访问控制符。局部内部类可以访问类中所有成员。

  匿名内部类:在定义的同时创建对象,它需要父类或父类接口来帮助定义。

  new SuperClass(){实现父类的抽象方法}。

  匿名内部类没有构造函数,但是它会调用父类的构造函数。

  匿名内部类中使用外部类的局部变量,保证局部变量被初始化,用final修饰变量称为常量。在定义匿名内部类的同时会获取到匿名内部类的对象。