java面向对象(一)

面向对象#

  我们都说java是面向对象的编程语言,那什么是面向对象呢?什么是类呢?什么是方法呢?

类、对象、方法

  类是对象的抽象定义,对象是类的具体实例。

  :指的是一类东西,比如汽车,人类,书等这些都指的是一类东西或物品。

  对象:指类的具体的实体,比如一辆汽车,一本书等,我们要记住一切皆对象(东西)。

  同时对象具有状态(属性)和行为(方法)

 我以人为例:
  人属性有:脸,手,脚,鼻子,耳朵,身高,性别,鼻子,耳朵等属性
  人的行为(方法):吃,喝,跑,睡觉等。

 这几个大家都能理解吧,而java中是如何创建类和对象的呢

 先创建一个学生类(这些都是学生的属性和方法)

public class Student {
    String name;      //姓名
    int age;           //年龄
    String classNo;    //班级
    String hobby;     //爱好

	public void chi(){
		System.out.println(name+"吃饭了")
	}

    //输出信息方法
    public void show(){
        System.out.println(name + "\n年龄:" + age + "\n就读于:" +classNo + "\n爱好:" + hobby);
    }
}

  这样就创建好一个类了,那如何创建一个对象呢。

  首先举一个例子:小李设计了一张汽车设计图,然后交给生产车间来生产汽车,有黑色的、红色的、白色的... 这里,汽车设计图就是我们说的类(class),生产车间就是new构造器(大部分对象都是new出来的),生产出来的汽车就是我们要说的对象。可以说java编程实质就是构建类的过程。

public class InitialStudent {
    public static void main(String args[]){
        Student student = new Student();    //建立对象
        student.name = "小明";            //给对象赋值
        student.age = 10;
        student.classNo = "S1班";      
        student.hobby = "篮球";
		student.chi();
        student.show();            //调用方法
	} 
}

  到现在我都是以自己的组织的语言给大家讲解,为的是让大家能够理解,那么java编程的规范有哪些,它的具体的细节又有哪些下面我就具体讲一下

类的定义

  类必须先定义才能使用。类是创建对象的模板,创建对象也叫类的实例化。(类是对象的抽象定义,对象是类的具体实例)类实质上是一个数据类型。

例子:

public class Dog
{
   String name;
   int age;

   void bark()//汪汪叫
   {
       System.out.println("汪汪,不要过来");
   }
   void hungry()
   {
       System.out.println("主人,我饿了");
   }
}

对示例的说明:

  • public 是类的修饰符,表明该类是公共类,可以被其他类访问。

  • 一个类保存到一个文件中,并且文件名要与类名相同。(一个文件中可以运行多个类声明,只能有一个类是public,文件名必须和该类类名一致)

  • class 是定义类的关键字。

  • Dog是类的名称。

  • name,age是类的成员变量,也叫属性;bark(),hungry()是类中的函数,也叫方法。

  • 对象实例化: 类名 对象名 = new 类名(); //未实例化的对象不能访问其属性和方法

  • 访问属性:对象名.属性名

  • 访问方法:对象名.方法名(参数列表)

作用域修饰词

  1、public:public表明该数据成员、成员函数是对所有用户开放的,所有用户都可以直接进行调用

  2、private:private表示私有,私有的意思就是除了class自己之外,任何人都不可以直接使用,私有财产神圣不可侵犯嘛,即便是子女,朋友,都不可以使用。

  3、protected:protected对于子女、朋友来说,就是public的,可以自由使用,没有任何限制,而对于其他的外部class,protected就变成private。

作用域 当前类 同一package 子孙类 其他package
public
protected ×
friendly(默认) × ×
private × × ×

一个类可以包含以下类型变量:

  • 局部变量:在方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。

  • 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化(分配内存)。成员变量可以被类中的方法和特定类的语句访问。

  • 类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。static也是修饰符的一种。

  同时类也可以被final修饰,下面将会讲解finnal关键字和static关键字
  

比较 成员变量 局部变量
作用域 整个类中起作用(包括方法中) 只在方法中起作用
初始值 byte,short,int,long型是0
float,double型是0.0
char型是’\0’
boolean型是false
没有初始值,无法使用

  注:当局部变量与成员变量重名时,在方法中优先使用局部变量,方法中使用成员变量使用this,this代表当前类的当前对象。

static(静态)

  类的静态成员不依赖类的某一实例,可使用类名直接访问

1.静态变量(类变量)

当类第一次被加载(任何一个对象的声明,首先要加载类),该类的静态变量就分配独立内存,直到程序结束被回收。静态成员是公共的。(局部变量不能用static修饰)

比较 静态变量 成员变量
作用域 当前类 当前类
生命周期 类加载到程序结束 从对象产生到对象回收
使用方法 类名.静态变量名 对象名.成员变量名

  静态变量即类变量 成员变量即实例变量,对象实例化后才能使用

静态方法

  • 访问静态方法:类名.方法名(参数列表)

  静态方法在同一个类中被调用时,类名可以省略。普通成员方法必须在对象实例化后才可以调用

比较 静态方法 成员方法
调用 类名.方法名(参数) 对象名.方法名(参数)
调用普通方法 不能直接调用 同一个类中可以调用
调用静态方法 类名.方法名(参数) 类名.方法名(参数)
访问静态变量 类名.静态变量名 类名.静态变量名
访问成员变量 不能直接访问 同一类中可以直接访问
this关键字 不能使用 可以使用

static代码块

  static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会在类加载的时候执行一次

  一般用来加载静态资源比如加载图片,视频,音频等。

final

Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。

1.修饰类

  当用final修饰一个类时,表明这个类不能被继承。也就是说,如果一个类你永远不会让他被继承,就可以用final进行修饰。final类中的成员变量可以根据需要设为final,但是要注意final类中的所有成员方法都会被隐式地指定为final方法

  注:在使用final修饰类的时候,要注意谨慎选择,除非这个类真的在以后不会用来继承或者出于安全的考虑,尽量不要将类设计为final类。

修饰方法

  使用final方法的原因有两个。
   第一个原因是把方法锁定,以防任何继承类修改它的含义;
   第二个原因是效率。在早期的Java实现版本中,会将final方法转为内嵌调用。但是如果方法过于庞大,可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中,不需要使用final方法进行这些优化了。

  注:类的private方法会隐式地被指定为final方法。

修饰变量

  修饰变量是final用得最多的地方,也是重点阐述的内容

  对于一个final变量,

    如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;

    如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。

  • 类的final变量和普通变量有什么区别
  • 当用final作用于类的成员变量时,成员变量(注意是类的成员变量,局部变量只需要保证在使用之前被初始化赋值即可)必须在定义时或者构造器中进行初始化赋值,而且final变量一旦被初始化赋值之后,就不能再被赋值了。
public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = "hello";
        String d = "hello";
        String c = b + 2; 
        String e = d + 2;
        System.out.println((a == c));//true
        System.out.println((a == e));//false
    }
}

分析
  为什么第一个比较结果为true,而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了,当final变量是基本数据类型以及String类型时,如果在编译期间能知道它的确切值,则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方,相当于直接访问的这个常量,不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中,由于变量b被final修饰,因此会被当做编译器常量,所以在使用到b的地方会直接将变量b 替换为它的 值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了,不过要注意,只有在编译期间能确切知道final变量值的情况下,编译器才会进行这样的优化,比如下面的这段代码就不会进行优化:

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = getHello();
        String c = b + 2; 
        System.out.println((a == c));//这段代码的输出结果为false。
 
    }
 
    public static String getHello() {
        return "hello";
    }
}
  • 被final修饰的引用变量指向的对象内容可变吗
  • 引用变量被final修饰之后,虽然不能再指向其他对象,但是它指向的对象的内容是可变的。
public class Test {
    public static void main(String[] args)  {
        final MyClass myClass = new MyClass();
        System.out.println(++myClass.i);//结果为1
    }
}
 
class MyClass {
    public int i = 0;
}
  • final参数的问题
  • 无论参数是基本数据类型的变量还是引用类型的变量,使用final声明都不会防止你无意的修改而影响到调用方法外的变量
public class Test {
    public static void main(String[] args)  {
        MyClass myClass = new MyClass();
        StringBuffer buffer = new StringBuffer("hello");
        myClass.changeValue(buffer);
        System.out.println(buffer.toString());
    }
}
 
class MyClass {
 
    void changeValue(final StringBuffer buffer) {
        buffer.append("world");
    }
}

  运行这段代码就会发现输出结果为 helloworld。很显然,用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了,万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么,如果把final去掉了,然后在changeValue中让buffer指向了其他对象,也不会影响到main方法中的buffer,原因在于java采用的是值传递,对于引用变量,传递的是引用的值,也就是说让实参和形参同时指向了同一个对象,因此让形参重新指向另一个对象对实参并没有任何影响。

static final

  •   static作用于成员变量用来表示只保存一份副本,而final的作用是用来保证变量不可变。

  •   static final修饰的属性表示一旦给值,就不可修改,并且可以通过类名访问。

  •   static final也可以修饰方法,表示该方法不能重写,可以在不new对象的情况下调用。
      

方法

  • 为什么要有方法
    • 提高代码的复用性
  • 什么是方法
    • 完成特定功能的代码块。
  • 方法的格式
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
			方法体语句;
			return 返回值; 
		} 
  • 方法的格式说明
    • 修饰符:一般就用 public,static,final。
    • 返回值类型:就是功能结果的数据类型。
    • 方法名:符合命名规则即可。方便我们的调用。
    • 参数:
      • 实际参数:就是实际参与运算的。
      • 形式参数;就是方法定义上的,用于接收实际参数的。
    • 参数类型:就是参数的数据类型
    • 参数名:就是变量名
    • 方法体语句:就是完成功能的代码。
    • return:结束方法的。
    • 返回值:就是功能的结果,由return带给调用者。

构造方法(特殊的方法)

  在类实例化的过程中自动执行的方法叫做构造方法,它不需要你手动调用。构造方法可以在类实例化的过程中做一些初始化的工作。

  构造方法的名称必须与类的名称相同,并且没有返回值。

  每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认的构造方法。

public class Dog
{
  String name;
  int age;

  //构造方法,没有返回值
  Dog(String name1,int age1)
  {
     name = name1;
     age = age1;
     System.out.println("感谢主人领养了我");
  }

  //普通方法,必须有返回值
  void bark()
  {
     System.out.println("汪汪,不要过来");
  }

  void hungry()
  {
      System.out.println("主人,我饿了");
  }

  public static void main(String[] args)
  {
      //创建对象时传递的参数要与构造方法参数列表对应
      Dog myDog = new Dog("花花",3);
  }
}

运行结果:

感谢主人领养了我

package day23;
/*构造方法
 - 作用是用于初始化参数
 - 所有的数字变量全部设置为0
 - 所有的boolean类型全部设置为false
 - 所有的对象变量全部设置为null
 */
/*
 - 设计自己的构造方法
 -   方法名称必须和类的名称相同
 -   没有返回值
 */
/*
 - 如果自己写了有参的构造方法,那么编译器不会再提供
 - 默认的构造方法了
 - 如果我们还想用无参的构造方法,
 - 那么需要手动实现
 */
public class People 
{
    String name;
    String sex;
    int age;

    //无参的构造方法(可以不写编译器自动加上,前提是没有任何其他构造方法)
    People()//构造方法(可删掉,编译器默认加上)
    {
//      name = null;
//      sex = null;
//      age = 0;
    }

    //有参的构造方法
    People(String name,String sex,int age)
    {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    //部分初始化
    People(String name)
    {
        this.name = name;
    }

    People(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public static void main(String[] args)
    {
        People p = new People();
        System.out.println(p.name);
        System.out.println(p.sex);
        System.out.println(p.age);

        People p1 = new People("张三","男",30);
        System.out.println(p1.name+","+p1.sex+","+p1.age);

        People p2 = new People("老王");
        System.out.println(p2.name);

        People p3 = new People("小老虎",3);
        System.out.println(p3.name+","+p2.age);
    }
}

说明:

  • 构造方法不能被显式调用。

  • 构造方法不能有返回值,因为没有变量来接收返回值

创建对象

  对象是类的一个实例,创建对象的过程也叫类的实例化。对象是以类为模板来创建的。
  在Java中,使用new关键字来创建对象,一般有以下三个步骤:

  • 声明:声明一个对象,包括对象名称和对象类型

  • 实例化:使用关键字new来创建一个对象。

  • 初始化:使用new创建对象时,会调用构造方法初始化对象。
    例如:

Dog myDog;//声明一个对象
myDog = new Dog("花花",3);//实例化

也可以在声明的同时进行初始化:

Dog myDog = new Dog("花花",3);

访问成员变量和方法

通过已创建的对象来访问成员变量和成员方法,例如:

//实例化
Dog myDog = new Dog("花花",3);
//通过点号访问成员变量
myDog.name;
//通过点号访问成员方法
myDog.bark();

  下面的例子演示了如何访问成员变量和方法:

public class Dog
{
  String name;
  int age;

  Dog(String name1,int age1)
  {
     name = name1;
     age = age1;
     System.out.println("感谢主人领养了我");
  }

  void bark()
  {
    System.out.println("汪汪,不要过来");
  }

  void hungry()
  {
    System.out.println("主人,我饿了");
  }

  public static void main(String[] args)
  {
    Dog myDog = new Dog("花花",3);
    //访问成员变量
    String name = myDog.name;
    int age = myDog.age;
    System.out.println("我是一只小狗,我名字叫" + name + ",我" + age + "岁了");
    //访问方法
    myDog.bark();
    myDog.hungry();
  }
}

 **运行结果: **
   感谢主人领养了我
   我是一只小狗,我名字叫花花,我3岁了
   汪汪,不要过来
   主人,我饿了

  这些就是面向对象的基础知识,下来难一点的比如抽象类,接口,重载,重写等,我会在下一篇将。

posted @ 2017-09-05 15:03  杨洛平  阅读(835)  评论(5编辑  收藏  举报