黑马程序员_day05 面向对象(匿名对象,构造函数,this关键字)

时间:2023-02-19 18:29:17

---------------------- android培训、java培训 期待与您交流! ----------------------
一:理解面向对象:
 1,面向对象是相对面向过程而言。

 2,面向对象和面向过程都是一种思想。
  注意面向对象特点:a,是一种思想.b,能让复杂问题简单化.c,能让我们角色转变执行者转换成指挥者.
  
  面向对象三个特征:封装,继承,多态。

 
       成员变量和局部变量。
  作用范围:
  成员变量作用于整个类中。
  局部变量变量作用于函数中,或者语句中。
  在内存中的位置:
  成员变量:在堆内存中,因为对象的存在,才在内存中存在。
  局部变量:存在栈内存中。

  注意:成员变量它都有默认值,定义完不赋值它是能参与运算,因为它在堆内存中,而局部变量不初始化
   不可能参与运算,因为它在栈内存中必须初始化,要有值才可以参与运算。


 3,面向过程。(注意:强调的是功能行为)

 4,面向对象。(注意:将功能封装进对象,强调具备了功能的对象)

 5,面向对象是基于面向过程的。

 
  2.1, 类和对象的关系。
   
    现实生活中的对象:张三 李四。
   
    想要描述:提取对象*性内容,对具体的抽象。
  
    描述时:这些对象的共性有:姓名,年龄,性别,学习java功能。

    映射到java中,描述就是class定义的类。

      具体对象就是对应java在堆内存中用new建立实体。
    类就是:对现实生活中事物的描述。
    对象:就是这类事物,实实在在存在的个体。


//需求:描述汽车(颜色,轮胎数)。描述事物其实就是在描述事物的属性和行为。

//属性对应是类中变量,行为对应的类中的函数(方法)。
//其实定义类,就是在描述事物,就是在定义属性和行为。属性和行为共同称为类中的成员(成员变量和成员方法)。

 

class Car
{
 //描述颜色
 String color = "红色";
 //描述轮胎数
 int num = 4;

 //运行行为。
 void run()
 {

  System.out.println(color+".."+num);
 }
 
}


class  CarDemo
{
 public static void main(String[] args)
 {
  //生产汽车。在java中通过new操作符来完成。
  //其实就是在堆内存产生一个实体。
  //Car c = new Car();//c就是一个类类型变量。记住:类类型变量指向对象。

  //需求:将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是:对象.对象成员
  //c.color = "blue";
  
  //c.run();

  //Car c1 = new Car();
  //c1.run();//red 4;


//  Car c = new Car();
//  c.num = 5;
  /*
  new Car().num = 5;
  new Car().color = "blue";
  new Car().run();

  Car c = new Car();
  c.run();
  c.num = 4;
  new Car().run();
  */
  //匿名对象使用方式一:当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化。
  //如果对一个对象进行多个成员调用,必须给这个对象起个名字。
  //匿名对象使用方式二:可以将匿名对象作为实际参数进行传递。


  Car q = new Car();
  show(q);

  //show(new Car());
 }

 //需求:汽车修配厂。对汽车进行改装,将来的车够改成黑车,三个轮胎。
 public static void show(Car c)
 {
  c.num = 3;
  c.color = "black";
  c.run();
 }
}

 

二:匿名对象

 1,匿名对象是对象的简化形式。

 2,匿名对象两种使用情况。

  a,当对对象(方法)仅进行(一次)调用的时候。

  b,匿名对象可以作为实际参数进行传递。

class Car
{
 //描述颜色
 String color = "红色";
 //描述轮胎数
 int num = 4;

 //运行行为。
 void run()
 {

  System.out.println(color+".."+num);
 }
 
}


class  CarDemo
{
 public static void main(String[] args)
 {
  //生产汽车。在java中通过new操作符来完成。
  //其实就是在堆内存产生一个实体。
  //Car c = new Car();//c就是一个类类型变量。记住:类类型变量指向对象。

  //需求:将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是:对象.对象成员
  //c.color = "blue";
  
  //c.run();

  //Car c1 = new Car();
  //c1.run();//red 4;


//  Car c = new Car();
//  c.num = 5;
  //匿名对象:
  new Car().num = 5;
  new Car().color = "blue";
  new Car().run();

  Car c = new Car();
  c.run();
  c.num = 4;
  new Car().run();
  
  //匿名对象使用方式一:当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化。
  //如果对一个对象进行多个成员调用,必须给这个对象起个名字。
  //匿名对象使用方式二:可以将匿名对象作为实际参数进行传递。


  Car q = new Car();
  show(q);

  //show(new Car());
 }

 //需求:汽车修配厂。对汽车进行改装,将来的车都改成黑车,三个轮胎。
 public static void show(Car c)
 {
  c.num = 3;
  c.color = "black";
  c.run();
 }
}


三:封装(Encapsulation)。private

 1,封装:是指影藏对象的属性和实现细节,仅对外提供公共访问方式。
 
 2,好处:a,将变化隔离。 b,便于使用。 c,提高重用性。 d,提高安全性。

 3,封装原则:a,将不需要对外提供的内容都影藏起来。
      b,把属性都影藏,提供公共方法对其访问。

/*
private关键字:
 a,是一个权限修饰符
 b,用于修饰类中的成员(成员变量,成员函数)。
 c,被私有化的成员只在本类中有效。

private常用之一:将成员变量私有化,对外提供对应的set,get方法对其进行访问。提高对数据访问的安全性。

将age私有化以后,类以外即使建立了对象也不能直接访问。
但是人应该有年龄,就需要在Person类中提供对应访问age的方式。

注意:私有仅仅是封装的一种表现形式。


之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句。
对访问的数据进行操作。提高代码健壮性。

*/

class Person
{
 private int age;//一个成员变量通常都会对应两种访问方式,一个是设置另一个是获取。
 public void setAge(int a)
 {
  if(a>0 && a<130)
  {
   age = a;
   speak();
  }
  else
   System.out.println("feifa age");
 }

 public int getAge()
 {
  return age;
 }
 private void speak()
 {
  System.out.println("age="+age);
 }
}

class PersonDemo
{
 public static void  main(String[] args)
 {
  Person p = new Person();

  //p.age = -20;
  p.setAge(-40);
  //p.speak();
 }
}

四:构造函数和构造代码块。

 1,特点:a,函数名与类名相同。 b,不用定义返回值类型。 c,不可以写return语句。

 2,作用:给对象进行初始化。

  注意:a,默认构造函数的特点。 b,多个构造函数是以重载的形式存在的。
 
 3,构造函数的小细节:
   当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。
   当在类中自定义了构造函数后,默认的构造函数就没有了。

 4,注意:一个对象建立,构造函数只运行一次。而一般方法可以被该对象调用多次。


/*
对象一建立就会调用与之对应的构造函数。

构造函数的作用:可以用于给对象进行初始化。

构造函数的小细节:
当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。

当在类中自定义了构造函数后,默认的构造函数就没有了。


构造函数和一般函数在写法上有不同。

在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行,是给对象添加对象具备的功能。

一个对象建立,构造函数只运行一次。
而一般方法可以被该对象调用多次。

什么时候定义构造函数呢?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。


*/

class Person
{
 private String name;
 private int age;
 
 /*
 构造代码块。
 作用:给对象进行初始化。
 对象一建立就运行,而且优先于构造函数执行。
 和构造函数的区别:
 构造代码块是给所有对象进行统一初始化,
 而构造函数是给对应的对象初始化。

 构造代码快中定义的是不同对象共性的初始化内容。

 */
 {
  //System.out.println("person code run");
  cry();
 }

 Person()
 {
  System.out.println("A: name="+name+",,age="+age);
  
 }
 /**/
 Person(String n)
 {
  name = n;
  System.out.println("B: name="+name+",,age="+age);

  //cry();
  
 }
 /*
 public void setName(String n)
 {
  name  = n;
 }
 public String getName()
 {
  return name;
 }
 */
 Person(String n,int a)
 {
  name = n;
  age = a;
  System.out.println("C: name="+name+",,age="+age);
  //cry();
 }

 public void cry()
 {
  
  System.out.println("cry......");
 }
}

class  PersonDemo2
{
 public static void main(String[] args)
 {
  Person p1 = new Person();

  

  Person p2 = new Person("lisi");
 
  //System.out.println(p2.getName());

  //Person p3 = new Person("wnagu",10);
 
  
 }
}

 

五:this关键字。


/*
this:看上去,是用于区*部变量和成员变量同名情况。
this为什么可以解决这个问题?
this到底代表的是什么呢?

this:就代表本类的对象,到底代表哪一个呢?
 this代表它所在函数所属对象的引用。
 简单说:哪个对象在调用this所在的函数,this就代表哪个对象。


this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
  但凡本类功能内部使用了了本类对象,都用this表示。

*/

class Person
{
 private String name;
 private int age;
 Person(int age)
 {
  this.age = age;
 }
 Person(String name)
 {
  this.name = name;
 }
 Person(String name,int age)
 {
  this.name = name;
  this.age = age;
 }

 public void speak()
 {
  System.out.println("name="+this.name+"...age="+this.age);
  this.show();
 }
 public void show()
 {
  System.out.println(this.name);
 }

 /*
 需求:给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
 */
 public boolean compare(Person p)
 {
  return this.age==p.age;

 }
}

class PersonDemo3
{
 public static void main(String[] args)
 {

  Person p1 = new Person(20);
  Person p2 = new Person(25);
  boolean b = p1.compare(p2);
  System.out.println(b);


  //Person p = new Person("lisi");
  //Person p1 = new Person("zhangsan");
  //p.speak();
  //p1.speak();
  //p.speak();
 }
}


六:this关键字在构造函数间调用。

/*
this:看上去,是用于区*部变量和成员变量同名情况。
this为什么可以解决这个问题?
this到底代表的是什么呢?

this:就代表本类的对象,到底代表哪一个呢?
 this代表它所在函数所属对象的引用。
 简单说:哪个对象在调用this所在的函数,this就代表哪个对象。


this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
  但凡本类功能内部使用了了本类对象,都用this表示。

*/

class Person
{
 private String name;
 private int age;
 Person(int age)
 {
  this.age = age;
 }
 Person(String name)
 {
  this.name = name;
 }
 Person(String name,int age)
 {
  this.name = name;
  this.age = age;
 }

 public void speak()
 {
  System.out.println("name="+this.name+"...age="+this.age);
  this.show();
 }
 public void show()
 {
  System.out.println(this.name);
 }

 /*
 需求:给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
 */
 public boolean compare(Person p)
 {
  return this.age==p.age;

 }
}

class PersonDemo3
{
 public static void main(String[] args)
 {

  Person p1 = new Person(20);
  Person p2 = new Person(25);
  boolean b = p1.compare(p2);
  System.out.println(b);


  //Person p = new Person("lisi");
  //Person p1 = new Person("zhangsan");
  //p.speak();
  //p1.speak();
  //p.speak();
 }
}

 

 

---------------------- android培训、java培训 期待与您交流! ----------------------