黑马程序员————学习日记【5】 【Java面向对象1】

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

//面向对象：三个特征：封装，继承，多态。

//以后开发：其实就是找对象使用。没有对象，就创建一个对象

//找对象，建立对象，使用对象。维护对象的关系。

/*
类和对象的关系

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

这个描述在java中是用类的形式来体现的，而对象是在java中通过new操作符所
产生的实体，此实体在堆内存中。把上面的这些东西映射的内存里面，一个是
类，一个是实体。

映射到java中，描述就是class定义的类。
具体对象就是对应java在堆内存中用new建立实体。

对象也是用于存储数据的，凡是用于存储多个数据的都称之为实体，都放在
堆内存中。

类：就是对现实生活中事物的描述。
对象：就是这类事物，实实在在存在的个体。
*/

//需求：描述汽车(颜色，轮胎数)【描述事物其实就是在描述事物的属性和行为】
//描述事物就是两部分：一是事物的属性，二是事物的行为。

//属性对应的是类中变量，行为对应的是类中的函数(方法)。
//其实定义类，就是在描述事物，就是在定义属性和行为。
//属性和行为共同称为类中的成员，一个是成员变量，一个是成员函数(方法)。
class Car
{
//首先描述颜色【颜色是个属性，是一个具体的值，此值要么是红色/蓝色
//是个字符串。此值是个数据类型，用String来描述。】

String color = "红色";
//接下来是轮胎数，这是个具体的数值，是整数，用int类型
//描述轮胎数

int num = 4;

//运行行为
void run()
{
System.out.println(color+"..."+num);
}
}

class  CarDemo
{
public static void main(String[] args)
{
//生产汽车。在java中通过new操作符来完成。
//其实就是在堆内存中产生一个实体。
//new Car();//产生了一个对象，此对象已经具备了颜色和轮胎数。
Car c = new Car();//为了方便操作，给它起个名字。
//c叫做句柄或引用型变量,c就是一个类类型变量。
//记住：类类型变量指向对象。类类型变量肯定会指向该类产生的实体

//需求：将已有车的颜色改成蓝色。就需要指挥该对象做事情，在java
//中的指挥方式是 ： 对象.对象成员。
c.color = "blue";

c.run();

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

//用new来建立对象，把现实生活中的对象在堆内存中产生，对象的特点
//在于封装数据，数据包含着属性和行为。想要操作对象中的内容，就
//指挥对象做事情就行了，指挥和操作都要明确一下，就是：对象.的
//形式来完成。

/*
备注：

1、发现Car中没有主函数，而其主要功能是，保证类的独立运行。
当类只为了描述事物，而不需要独立运行可以不写主函数。
如果还想使用类中的东西，那么只需建立该类的对象即可。

我们写多个类，描述多个事物，只要写一个主函数就可以了。
在主函数中建立那么多类的对象，并调用它的功能就可以了。

所以主函数就是个入口，用于调用别人。

2、

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

发现这个比较特别，以前都定义在函数里面，现在定义在函数外面了。
这个称之为成员变量，以前写的叫局部变量。
二者的不同在于：

(1)作用范围
成员变量：作用于整个类中
局部变量：作用于函数中，或者语句中。
(2)在内存中的位置
成员变量：在堆内存中，因为对象的存在，才在内存中存在
局部变量：存在栈内存中
*/

//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();

}
}

 
 




 

/*
private:私有，权限修饰符，用于修饰类中的成员(成员变量，成员函数)
私有只在本类中有效。

将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;
}

void speak()
{
System.out.println("age="+age);
}
}

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

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

 
 

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

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

即当我们在堆内存中产生对象的时候，此对象需要一个初始化动作。

构造函数小细节：
当一个类中没有定义构造函数时，则系统默认给该类加入一个空参数的构造函数
这样就方便了该类进行初始化。

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

*/

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

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

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

构造函数在对象建立时执行，而且只执行一次。

方法必然被对象调用，在没有被静态之前。
*/

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

构造函数在进行定义时，需不需要未知内容参与运算呢？
需要，就定义参数。

构造代码块中定义的是不同对象共性的初始化内容。
*/
class Person
{
private String name;
private int age;

/*
构造代码块
作用：给对象进行初始化
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
*/

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

Person()
{
System.out.println("A:name="+name+",,age="+age);
//		cry();
}
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)
{
nam
4000
e = 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");
//		p2.setName("libusi");
//		p2.setName("HAISHILISI");
//		System.out.println(p2.getName());

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

 

/*
this关键字：看上去是区分局部变量和成员变量的同名情况。
this为什么可以解决这个问题？
this到底代表的是什么？

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

this的应用：当定义类中功能时，该函数内部要用到调用函数的对象时，
此时用this来表示这个对象。

但凡是本类功能内部用到本类对象的时候，都用this表示。

//
*/
class Person
{
private String name;
private int age;
Persong(int age)
{
this.age = age;
}

Person(String name)
{
this.name = name;
}
Person(String n,int a)
{
this.name = name;
this.age = age;
}

public void speak()
{
System.out.println("name="+this.name+"...age="+this.age);
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();
}
}

 



 

/*
this语句:用于构造函数之间进行互相调用。

构造函数间调用只能用this语句，用的时候要传相应的参数。

有些时候，构造函数有很多，但对外提供的却不多。有可能仅对外提供一个，
而内部却有很多种初始化方式。所以，内部的初始化方式可以把它私有起来，
只对外暴露一个。这样，用户用起来很方便，而我这里面有我内部的初始化动作。

注意：this语句只能定义在构造函数的第一行。 否则编译失败。
因为初始化动作要先执行，而且只执行一次。
*/
class Person
{
private String name;
private int age;

Person()
{
this("haha");
}
Person(String name)
{
//		this();//不允许存在，死循环
this.name = name;
}

Person(String name,int age)
{
//		this.name = name;
//		this(name);//this语句 p(name);
this.age = age;
}
}

class  PersonDemo4
{
public static void main(String[] args)
{
new Person();
//		Person p = new Person("lisi",30);
//		Person p1 = new Person("lisi2",36);
}
}

/*
静态：static
用法：是一个修饰符，用于修饰成员(成员变量，成员函数)。

静态修饰的内容被对象所共享。

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
还可以直接被类名调用。格式：类名.静态成员

特有内容随着对象存储在堆内存中。

static特点：
1、随着类的加载而加载(即静态随着类的消失而消失)
这说明：静态的生命周期最长。

2、优先于对象存在
明确一点：静态是先存在，对象是后存在的。

3、被所有对象所共享
4、可以直接被类名所调用

注意：
不建议定义过多的静态变量，什么时候定义，要区分这数据
是不是被多个对象所共享，是，就静态;不是，千万别静态。

实例变量和类变量的区别：
1、存放位置：
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2、生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。

静态使用注意事项：
1、静态方法只能访问静态成员(包括方法和变量)
非静态方法既可以访问静态也可以访问非静态。
2、静态方法中不可以定义this，super关键字。
因为静态优先于对象存在，所以静态方法中不可以出现this.
3、主函数是静态的。

静态有利有弊
好处：(1)对对象的共享数据进行单独空间的存储，节省内存。
没有必要每一个对象中都存储一份。
(2)可以被类名调用

注意：如果想使用一个类中的成员，一般情况，先建立那个类的
对象，调用它里面的方法。如此类没对象，那就得用类名
调用，就得在成员当中定义几个静态成员。

弊端：(1)生命周期过长。
(2)访问出现局限性。(即静态虽好，只能访问静态)
*/

class Person
{
String name;//成员变量，实例变量。
static String country = "CN";//静态的成员变量，类变量。
public static void show()
{
System.out.println(":::::"+this.name);
this.haha();
}
public void haha()
{}
}
class StaticDemo
{
public static void main(String[] args)
{
//		Person p = new Person();
//		p.name = "zhangsan";
//		p.show();

//		System.out.println(p.country);

//		System.out.println(Person.country);

Person.show();
}
}

/*
1、为什么使用静态？(要从两方面下手)
因为静态修饰的内容有成员变量和函数。

2、什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。

备注：张三和李四都有姓名，但是姓名不是共享数据，那是共享
属性。所说的共享数据是一个值。传智播客的学员都有姓
名，这称之为对象的特有数据。 但是，张三和李四(大家)
都是传智播客的学员，这样 传智播客 学校名称 = 传智播客
，这个变量就可以定义成静态变量。他们也是学生事物中的
一个成员，一个共享成员。分析到这里，为了增加程序的严
谨性，为了更符合描述事物的本质，更贴切，就需要加静态
来修饰 学校名称 = 传智播客 这个变量。

3、什么时候定义静态函数呢？【死记硬背也得记住】
当功能内部没有访问到非静态数据(对象的特有数据)，那么
该功能可以定义成静态。

*/
class Person
{
String name;//定义一个变量

public static void show()
{
System.out.println("haha");
//此方法很单一，没有访问name。
//即功能没有操作(访问)对象的特有数据
//所以要加静态(static)
}
}

class
{
public static void main(String[] args)
{
Person p = new Person();
//Person对象一用出来，Person对象在堆内存中有name属性
//建立对象的目的是：为了封装数据，为了把张三、李四这
//两个数据单独分开存放。
//对象的出现为了封装数据，建立了对象之后，还没使用到
//该数据，那建立就失去了意义。new Person(new 对象)，
//搞内存里面去了，调用功能，还没处理数据，那功能就没
//必要使用对象了。
//如果仅仅想显示一下，这样Person.show();就可以了
p.show();
//而调用show的时候，和Person对象的特有属性没关系
//		如果想显示 姓名 + haha,上面就变为 (name+"haha");
//		这样，这个功能就能访问到对象中的数据了。如果此时
//		写静态，就不行。因为当public static void show()
//		加载的时候，name是不在的，这时候绝对不能写静态。
//		因为只有有了对象Person p = new Person();之后，此
//		功能p.show();才有意义。
}
}

 

对象的初始化过程