面向对象是Java语言的基本思想。类是Java中最核心最基本的内容。
类
类,是Java语言的基础,任何的操作都要在一个类中完成,如方法,构造函数,参数的传递等等。
类的一般形式, class 类名{
类型 变量名;
类型 变量名;
......
类型 方法名(参数){
方法内容}
......}
如 class People{
String name;
String sex;
Int age;
void eat(){
Ststem.out.println(“我在吃饭”);}
void tea(){
Ststem.out.println(“我在喝茶”);}
......}
有时声明类时,需要在类的前面加上修饰符进行修饰。
private 只在本类中可见
protected 在本类或者同一个包中可见
public 对任何类可见
没有加修饰符的变量,默认为private
方法分为有返回类型方法和无返回类型方法两种:不需要返回值,可以使用void进行修饰;如需要返回值,方法的类型定义必须和返回值的类型相同:如public String ear(){
return "我在吃饭";}
使用带参数的方法的一般形式如下:
修饰符 类型 方法名(参数类型 参数1,参数类型 参数2...){
方法体}
主方法
一个程序写好之后,如何去运行,从哪里去运行?主方法就是程序的入口
package ch02;
public class People {
<span style="white-space:pre"> </span>private String name;
<span style="white-space:pre"> </span>private String sex;
<span style="white-space:pre"> </span>private int age;
<span style="white-space:pre"> </span>public People(){
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>}//自己设计的构造方法
<span style="white-space:pre"> </span>public String eat(String food) {
<span style="white-space:pre"> </span>return "我在吃" + food;
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>public void tea() {
<span style="white-space:pre"> </span>System.out.println("我在喝茶。");
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>// 调用eat()和tea()
<span style="white-space:pre"> </span>public static void main(String[] args) {
<span style="white-space:pre"> </span>String str = new People().eat("apple");
<span style="white-space:pre"> </span>System.out.println(str);
<span style="white-space:pre"> </span>new People().tea();
<span style="white-space:pre"> </span>}
}
构造方法
在程序中创建对象时,也需要清除或者修改其属性的值,这就是构造方法
构造方法,是类中比较特殊的一种方法,主要用于初始化一些参数。
Java中提供有默认的构造方法,如果在类中没有提供自己的构造方法,在编译时,编译器就会为这个类添加一个构造方法。构造方法的语法如下
People people = new People();
这个语句中,构造方法People()实际完成的效果是People(){name = null;sex = null;age = 0;}
如果在类中设计了自己的构造方法,那么构造方法的名称必须要和类的名称相同,且没有返回值。在类中提供自己的构造函数后,在编译时,编译器就不会提供默认的构造函数了。在创建对象时,就需要自己添加参数,也就是各属性被初始化的值。
package ch02;
public class PeopleConstructor {
private String name;
private String sex;
private int age;
public PeopleConstructor(String iname, String isex, int iage) {
name = iname;
sex = isex;
age = iage;
}
public String eat(String food) {
return "我在吃" + food;
}
public void tea() {
System.out.println("我在喝茶。");
}
// public static void main(String[] args) {
// PeopleConstructor P = new PeopleConstructor();
// System.out.println("初始值" + P.name);
// System.out.println("初始值" + P.sex);
// System.out.println("初始值" + P.age);
// }
public static void main(String[] args) {
PeopleConstructor P = new PeopleConstructor("dby", "man", 22);
System.out.println("姓名:" + P.name);
System.out.println("性别:" + P.sex);
System.out.println("年龄:" + P.age);
}
}
成员变量
又称全局变量,定义在类中,和方法出于同一个层次。语法:变量修饰符 类型 变量名
成员变量名称可以和类中的方法同名
局部变量
是在方法中定义和使用的,它的使用范围仅限于所声明的方法中。不同方法内定义的变量名可以相同。
this关键字
使用this关键字可以不通过对象,引用成员变量和方法
如果成员变量和方法中的参数名相同时,this很重要
package ch02;
public class ThisTwoTest {
String eat = "吃饭时间";
String tea = "下午茶时间";
int i = 16;
public void eat(int i) {
if (i > 11 && i < 14) {
System.out.println("现在时间是:" + i + "点,是" + eat);
} else if (i > 15 && i < 17) {
System.out.println("现在时间是:" + i + "点,是" + tea);
}
}
public void tea(int i) {
if (this.i > 11 && this.i < 14) {
System.out.println("现在时间是:" + this.i + "点,是" + eat);
} else if (this.i > 15 && this.i < 17) {
System.out.println("现在时间是:" + this.i + "点,是" + tea);
}
}
public static void main(String[] args) {
ThisTwoTest t = new ThisTwoTest();
t.eat(12);// eat直接传12,现在时间是:12点,是吃饭时间
t.tea(12);// 有this关键字,使用的是成员变量this.i,现在时间是16点,是下午茶时间
}
}
有时要在一个构造函数中调用另一个构造函数,而构造函数之间的差别也仅在于其中的参数,使用this关键字时,编译器可以根据其中的参数来寻找不同的构造方法
package ch02;
public class ThisConstructor {
String name;
public ThisConstructor(String name) {
this.name = name;
System.out.println("姓名:" + this.name);
}
public ThisConstructor() {
this("张三");
}
public static void main(String[] agrs) {
new ThisConstructor();
}
}
对象可以是任何物体,抽象的事物也可以是一个对象
创建和使用对象
语法: 类名 对象名 = new 类名(参数列表)
对象行为和属性访问
在获得一个类的对象实体后,在对象实体后加 . 就可以调用对象的属性,如果想得到对象的行为,也可以采用同样的方式
package ch02;
public class Car {
public String color;
public String brand;
public int number;
public Car(String color, String brand, int number) {
this.color = color;
this.brand = brand;
this.number = number;
}
public void run() {
System.out.println("running");
}
public static void main(String[] args) {
Car car = new Car("white", "BMW", 52588);
System.out.println("汽车的颜色是:" + car.color);
System.out.println("汽车的牌子是:" + car.brand);
System.out.println("汽车的牌照是:" + car.number);
car.run();
// System.out.println(this.number);
// 仔细看看main()方法就不难发现,
// 主函数是一个静态(static)方法。
// 这里就引入了另外一个知识点,
// static修饰的方法内部是不允许出现非静态成员变量或成员方法,
// 即static修饰的方法与该类相关,但是不跟该类的具体实例相关,
// 而this(即对象)是具体类的对象实例,因此这里就会在编译的时候报错。
// 静态方法不需要对象就能调用,类名.方法名 ,
// 所以如果静态方法里面出现this,就不知道this是哪个对象的引用,
// 因为有可能根本就不是对象调用方法的。
}
}
比较对象
在程序中,使用“==”和equals方法来进行对象的比较。
使用“==”判断的是二者是否为同一个对象,比较的是两个对象的地址,即使两个对象的内容相同,地址不同也会输出false
使用equals比较的是两者的值,即便不是同一个对象,只要值相同,就会输出true
销毁对象
垃圾回收机制(GC),使用方法:System.gc()
垃圾回收机制用来管理使用new关键字创建的对象所占用的内存资源