javaObject

朱雀 2022-06-07 00:35 252阅读 0赞

一、 Java面向对象

从客观系统的描述分类，程序设计语言分为面向过程语言和面向对象语言。面向过程语言以“数据结构+算法”程序设计范式构成，如Basic，c等。

以“对象+消息”程序设计范式构成的程序设计语言，称为面向对象语言。比如，java，c++，vb等。面向对象的语言依据现实世界的组成，以事物为中心设计，具有更接近人类思维、可封装提高信息隐藏性和重用性高的特点。根据现实世界事物具有静态属性和动态动作的特点，面向对象的语言也为对象设计了属性和方法两个基本成员。为了进一步提高面向对象的重用性，引入了类的概念，即将对象中公共的成员抽象为一个类。简单的说，类就是具有相同属性和方法的一组对象的集合，如男人和女人都属于人类，猫狗都是动物类。类构成了java程序的基本组织单元。在java中，使用某个类下的对象，可以通过实例化类来完成，一般使用new关键字。实例化的对象可以调用类中非私有的成员。

二、 类的创建与实例化

  1. 一般，类通过class关键字创建，通过其他关键字可以设置类的一些特性，如访问权限，静态与否，抽象与否，同步与否。类的成员包括属性和方法，另外还有用于实例化类的构造方法，构造方法是一种特殊的方法，创建类时没有写构造方法则采用程序默认的无参构造方法。

创建类的例子：

  1. public class Dog {
  3.    public Stringname;
  5.    public intage;
  7.    public Dog(){
  9.       System.out.println("无参的构造方法");
  11.    }
  13.    public voidchi(){
  15.       System.out.println(name+"狗吃");
  17.    }
  19. }

测试

  1.    public voidtest1(){
  3.       Dog d=new Dog();
  5.       d.name="匹配";
  7.       d.chi();
  9.    }
  1. 构造方法的重载

一个类可以有多个构造方法，以便创建不同需求的实例对象。构造方法的重载指，方法名相同，参数列表不同。其中，参数列表不同指参数的个数和类型上的不同。

例子：

创建多个构造方法的类

  1. public class Person {
  3.    public Stringname;
  5.    public intage;
  7.    public Person(){
  9.       System.out.println("无参的构造函数");
  11.    }
  13.    public Person(Stringname){
  15.       System.out.println("一个参数的构造函数");
  17.    }
  19.    public Person(Stringname,intage){
  21.       System.out.println("两个参数的构造函数");
  23.    }
  25. }

测试

  1.    public voidtest2(){
  3.       Person p1=new Person();
  5.       Person p2=new Person("看看");
  7.       Person p3=new Person("看看",13);
  9.    }

三、 Java面向对象的特征

(一) 封装

封装就是将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的步骤：1，把要封装的成员属性的访问权限设为private；2，在类中提供set方法以便设置属性值，可以使用this关键字，简化代码；3，提供get方法以便获取属性值。

this关键字表示本类的对象。

例子：

创建进行了封装的类

  1. public class Dog {
  3.    private Stringname;
  5.    private intage;
  7.    public voidsetName(String name){
  9.       this.name=name;
  11.    }
  13.    public String getName(){
  15.       return this.name;
  17.    } 
  19.    public intgetAge() {
  21.       return age;
  23.    }
  25.    public voidsetAge(intage){
  27.       this.age =age;
  29.    }
  31.    public Dog(){
  33.       System.out.println("无参的构造方法");
  35.    }
  37.    public voidchi(){
  39.       System.out.println(name+"狗吃");
  41.    }
  43. }

测试

  1.    public voidtest1(){
  3.       Dog d=new Dog();
  5.       d.setName("浏览");
  7.       System.out.println(d.getName());
  9.       d.chi();
  11.    }

(二) 继承

  1. 继承是从已有的类中派生出新的类，新的类能吸收已有类的成员属性和行为，并能扩展新的能力。Java不支持多继承，一个类只能有一个父类。继承具有传递性，如果继承的父类也继承了这个父类的父类，这可以继承父类的父类，但是不允许递归继承。使用继承可以避免对一般类和特殊类之间共同特征进行的重复描述。继承具有传递性，使用方法的重写可以提高复用功能，继承有利于维护。

例子：

创建父类和子类

  1. public class Animal {
  3.    public Stringname;
  5.    public intage;
  7.    private Stringsex;
  9.    public voideat(){
  11.       System.out.println(name+"在吃");
  13.    }
  15.    private voidwang(){
  17.       System.out.println(name+"在旺旺");
  19.    }
  21. }
  25. public class Dog1 extends Animal{
  29. }
  33. public class Cat extends Animal{
  37. }

注意：子类不能继承父类私有的成员，子类与父类非同包而父类中使用默认访问权限的成员，父类的构造方法。

  1. 子类访问父类成员，使用super关键字。

例子：

创建父类和子类

  1. public class Animal {
  3.    public Stringname="哈哈";
  5.    public intage;
  7.    private Stringsex;
  9.    public voideat(){
  11.       System.out.println(name+"在吃");
  13.    }
  15.    private voidwang(){
  17.       System.out.println(name+"在旺旺");
  19.    }
  21. }
  25. public class Cat extends Animal{
  27.    public Stringname;
  29.    public Cat(){
  31.       //调用父类的构造方法，只能出现在构造方法的第一行。
  33.       super();
  35.    }
  37.    public voidcat(){
  39.       System.out.println(name+"是cat的name");
  41.       System.out.println(super.name+"是父类的name");
  43.    }
  45. }
  47. 测试
  49.    public voidtest4(){
  51.       Cat c=new Cat();
  53.       c.name="kitty";
  55.       c.cat();
  57.    }
  1. 关于java中访问权限

不同的访问权限，提供了对访问的控制。见下表。







































访问修饰符

本类

同包

字类

其他

private

√

 

 

 

默认（default）可以缺省

√

√

 

 

protected

√

√

√

 

public

√

√

√

√

例子略。

  1. 子类重写父类方法

如果子类根据自身的特殊性，需要对父类中的方法进行修改后使用，可以使用方法的重写实现。

方法重写的要求：1，重写的方法和被重写的方法具有相同的方法名；2，重写的方法与被重写的方法具有相同的参数列表；3，重写的方法的返回值类型和被重写方法的返回值类型相同或者是其子类；4，重写的方法不能缩小被重写方法的访问权限。

注意：由于构造方法不能被继承，所有不能重写构造方法。

例子：

创建父类和子类

  1. public class Animal {
  3.    public Stringname="哈哈";
  5.    public intage;
  7.    private String sex;
  9.    public voideat(){
  11.       System.out.println(name+"在吃");
  13.    }
  15.    private voidwang(){
  17.       System.out.println(name+"在旺旺");
  19.    }
  21. }
  25. public class Dog1 extends Animal{
  27.    public voideat(){
  29.       System.out.println(name+"狗自己的方法");
  31.    }
  33. }

测试

  1.    public voidtest5(){
  3.       Dog1 d=new Dog1();
  5.       d.name="Kk";
  7.       d.eat();
  9.    }

(三) 抽象

抽象就是对显示的一类事物，抽取其特点，并把这些特点整合在一起，提取为类来表示这类事物。Java中使用abstract关键字表示抽象的类。抽象类中可以没有成员，如果有成员方法是抽象的方法，如果有子类的话，要在其子类中重写这个抽象方法为非抽象的，除非这个子类也是抽象类。

没有成员的抽象类的例子：

创建抽象类及其子类

  1. public abstract class Animal2 {
  5. }
  9. public class Cat1 extendsAnimal2{
  13. }

具有成员的抽象类的例子：

创建抽象父类和子类

  1. public abstract class Animal2 {
  3.    String name;
  5.    int age;
  7.    public voidtest(){
  11.    }
  13.    abstract voidtest2();
  15. }
  19. public class Cat1 extends Animal2{
  21.    @Override
  23.    void test2() {
  25.       System.out.println("来自抽象父类的抽象方法");
  27.    }
  29. }

测试

  1.    public voidtest6(){
  3.       Cat1 c=new Cat1();
  5.       c.test2();
  7.    }

(四) 多态

方法的重写、重载和动态链接构成多态性。Java只允许单继承，虽然保证了继承关系的简单明了，但是功能上有很大的限制，java的多态弥补了这个限制性。自动向上转型，帮助实现了多态性，即将父类的引用指向子类的对象，自动从小的类转成大的类型。

例子：

创建父类和子类

  1. public class Animal {
  3.    public Stringname="哈哈";
  5.    public intage;
  7.    private Stringsex;
  9.    public voideat(){
  11.       System.out.println(name+"在吃");
  13.    }
  15.    private voidwang(){
  17.       System.out.println(name+"在旺旺");
  19.    }
  21. }
  25. public class Dog1 extends Animal{
  27.    public Stringname="wang";
  29.    public voiddog(){
  31.       System.out.println(name+"多态中子类狗特有的方法");
  33.    }
  35. }
  39. public class Cat extends Animal{
  41.    public Stringname="miao";
  43.    public Cat(){
  45.       //调用父类的构造方法，只能出现在构造方法的第一行。
  47.       super();
  49.    }
  51.    public voidcat(){
  53.       System.out.println(name+"是cat的name");
  55.       System.out.println(super.name+"是父类的name");
  57.    }
  59.    public voidcat2(){
  61.       System.out.println(name+"多态中子类猫特有的方法");
  63.    }
  65. }

测试

  1.    public voidtest7(){
  3.       Animal dog=new Dog1();
  5.       Animal cat=new Cat();
  7.       test8(dog);
  9.       test8(cat);
  11.    }
  13.    public voidtest8(Animal a){
  15.       a.eat();
  17.       if(ainstanceofDog1){
  19.          ((Dog1)a).dog();
  21.       }
  23.       if(ainstanceofCat){
  25.          ((Cat)a).cat2();
  27.       }
  29.    }

注意：多态的方法提高了代码的复用性和扩展性，但是多态的对象不能使用子类特有的成员，如果使用，需要向下强制转换。

四、 接口

  1. 在java中，接口是一个抽象类型，是抽象方法的集合。接口无法被实例化，但可以被实现，一个实现接口的类，必须实现接口内所有方法，否则必须声明此类为抽象类。接口可以继承接口，支持多继承。接口可以用来声明变量。

例子：

创建一个接口

  1. public interface Interface1 {
  3.    public Stringname="hah";
  5.    public voidinter1();
  7. }

创建一个实现类

  1. public class InterfaceClass1 implements Interface1{
  3.    @Override
  5.    public voidinter1() {
  7.       System.out.println("实现了一个接口");
  9.    } 
  11. }
  1. 一个类可以同时实现多个接口

例子：

创建两个接口

  1. public interface Interface1 {
  3.    public Stringname="hah";
  5.    public voidinter1();
  7. }
  11. public interface Interface2 {
  13.    public Stringname="hah";
  15.    public voidinter2();
  17. }

创建一个实现类

  1. public class InterfaceClass1 implements Interface1,Interface2{
  3.    @Override
  5.    public voidinter1() {
  7.       System.out.println("实现了一个接口");
  9.    }
  11.    @Override
  13.    public voidinter2() {
  15.       System.out.println("实现了另一个接口");
  17.    } 
  19. }
  1. 一个接口可以继承多个接口

例子：

创建两个接口

  1. public interface Interface1 {
  3.    public Stringname="hah";
  5.    public voidinter1();
  7. }
  11. public interface Interface2 {
  13.    public Stringname="hah";
  15.    public voidinter2();
  17. }

创建一个接口继承多个接口

  1. public interface Interface3 extends Interface1,Interface2{
  3.    public Stringname="hah";
  5.    public voidinter3();
  7. }

注意：如果一个类实现了一个具有继承关系的接口，则这个实现类要实现所有继承的接口的方法和本接口的方法。

如：

  1. public class InterfaceClass2 implements Interface3{
  3.    @Override
  5.    public voidinter1() {
  7.       // TODO Auto-generated methodstub  
  9.    }
  11.    @Override
  13.    public voidinter2() {
  15.       // TODO Auto-generated methodstub  
  17.    }
  19.    @Override
  21.    public voidinter3() {
  23.       // TODO Auto-generated methodstub  
  25.    }    
  27. }
  1. 接口不能被实例化，要使用接口需要通过实例化这个接口的类实现，接口支持多态。

例子：

创建接口和实现类略

  1.    public voidtest9(){
  3.       InterfaceClass1 in=new InterfaceClass1();
  5.       in.inter1();
  7.       //使用多态的方式
  9.       Interface1 in1=new InterfaceClass1();
  11.       in.inter1();
  13.    }
  1. 一个类可以同时继承一个类并实现接口

例子：

  1. public class InterfaceClass1 extends Animalimplements Interface1,Interface2{
  3.    @Override
  5.    public voidinter1() {
  7.       System.out.println("实现了一个接口");
  9.    }
  11.    @Override
  13.    public voidinter2() {
  15.       System.out.println("实现了另一个接口");
  17.    } 
  19. }

五、 static和final关键字

  1. static关键字

static，静态的意思，用于修饰类的成员，表示被修饰的成员是静态的。声明为静态的成员，属于类所有，不是个别的对象。由于static的成员被类所有，可以使用类名.成员名来调用静态的成员。静态的方法不能调用非静态的方法或属性。构造方法不能使用static修饰。

例子：

创建含静态成员的类

  1. public class StaticTest {
  3.    public staticString name;
  5.    public staticvoidtest1(){
  7.       System.out.println(name+"这是静态的方法");
  9.       //test2();
  11.    }
  13.    public voidtest2(){
  15.       test1();
  17.    }
  19.    /*public staticStaticTest(){
  21.       //构造方法不能使用static
  23.       System.out.println("无参的构造方法");
  25.    }*/
  27. }

测试

  1.    public voidtest10(){
  3.       StaticTest.name="haha";
  5.       StaticTest.test1();
  7.    }

static也可以修饰代码块，表示静态代码块。静态代码块在类加载的时候，完成初始化。

例子：

创建带有静态代码块的类

  1. public class StaticTest {
  3.    public staticString name;
  5.    public staticvoidtest1(){
  7.       System.out.println(name+"这是静态的方法");
  9.       //test2();
  11.    }
  13.    public voidtest2(){
  15.       test1();
  17.    }
  19.    /*public staticStaticTest(){
  21.       //构造方法不能使用static
  23.       System.out.println("无参的构造方法");
  25.    }*/
  27.    static{
  29.       name="hihi";
  31.       System.out.println("这是静态代码块");
  33.    }
  35. }

测试

  1.    public voidtest11(){
  3.       StaticTest.test1();
  5.    }
  1. final关键字

final表示最终的，可以修饰类，方法和属性。使用final修饰的类不能被继承；final修饰的方法不能被重写，但是可以被继承；final修饰的变量，代表变量不能被改变，所以又称之为常量，一般将常量名大写，如果是两个单词，则以_分割，如PI，STU_NAME。

例子：

  1. public final class FinalTest {
  3.    public finalString NAME="会话";
  5.    public finalvoidtest1(){
  7.       System.out.println("无返回值，不能被重写的final方法");
  9.    }
  11.    public finalint test2(){
  13.       System.out.println("有返回值，不能被重写的final方法");
  15.       return 1;
  17.    }
  19. }

发表评论

表情：
评论列表 （有 0 条评论，252人围观）

还没有评论，来说两句吧...

相关阅读

    相关 javaObject

    一、       Java面向对象 从客观系统的描述分类，程序设计语言分为面向过程语言和面向对象语言。面向过程语言以“数据结构+算法”程序设计范式构成，如Basic，c等。

    朱雀朱雀/ 0 赞/ 253 阅读

    相关 JavaBean和JavaObject理解

    JavaBean 1. Java是一门纯粹的面向对象的语言，但是又有基本数据类型，至少基本数据类型是没有引用的，也就是说基本数据类型不是对象，但是Java设计了基本数据

    清疚清疚/ 0 赞/ 386 阅读