编写学生类
package com.jian.demo1;
public class Student { //第一步:编写类,比如:学生类
//第二步:编写属性也叫做编写编写成员变量,比如:姓名、年龄、性别、身高、体重
String name; //默认值为null
int age; //默认值为0
char gender; //默认值为\u0000
double height; //默认值为0.0
double weight; //默认值为0.0
//第三步:编写方法,比如:学习
public void study(){
System.out.println("正在学习面向对象......");
}
}
编写测试类
package com.jian.demo1;
public class Test { //编写测试类
public static void main(String[] args) {
/*
根据类来创建对象,语法格式:类名 对象名 = new 类名();
当执行new运算符时,则表示创建一个对象,并且在堆内存中开辟一块空间存储一个对象,会自动分配一个内存地址,当前创建的是学生对象,则就会在该对象中存放5个属性,并且都是默认值
将对象的内存地址赋给左侧的对象名zs
*/
Student zs = new Student();
/*
输出对象中所有的属性值,语法格式:对象名.属性名
注意:当编写对象名.时,提示m表示为方法(method),提示f表示字段(field),其中字段也就是属性或者成员变量
*/
// System.out.println(name); //出现编译错误,原因:当前main方法中没有name属性,因此不能直接访问
System.out.println(zs.name); //null
System.out.println(zs.age); //0
System.out.println(zs.gender); //
System.out.println(zs.height); //0.0
System.out.println(zs.weight); //0.0
//实现对属性赋值,语法格式: 对象名.属性名 = 值;
zs.name = "张三";
zs.age = 19;
zs.gender = '男';
zs.height = 1.74;
zs.weight = 80.2;
//输出对象名zs中所有的属性值
System.out.println("姓名:" + zs.name + "\n年龄:" + zs.age + "\n性别:" + zs.gender + "\n身高:" + zs.height + "\n体重:" + zs.weight);
/*
访问对象中的方法,语法格式:对象名.方法名称([参数列表]);
注意:不能使用类名.方法名称,原因:当前方法没有编写static因此访问不到
*/
zs.study();
//一个类可以创建任意多个对象,因此来创建第二个学生对象
Student s2 = new Student();
System.out.println("s2.name = " + s2.name); //null
s2.study();
}
}
编写电脑类,属性:品牌、内存、价格、尺寸、颜色,方法:输出电脑的信息
package com.jian.demo2;
/**
* 编写电脑类,属性:品牌、内存、价格、尺寸、颜色,方法:输出电脑的信息
*
*/
public class Computer {
//编写属性也叫做编写成员变量或者编写字段f
String brand;
String memory;
int price;
double size;
String color;
//编写方法,输出电脑的信息,其实也就是将电脑中所有的属性值在该方法中输出
public void print(){
//可以在当前类中直接使用属性或者成员变量或者字段
System.out.println("品牌:" + brand + "\n内存:" + memory + "\n价格:" + price + "\n尺寸:" + size + "\n颜色:" + color);
}
}
编写电脑测试类,创建电脑对象,调用方法输出所有信息
创建电脑对象,完成对所有属性赋值,并调用方法输出电脑信息
package com.jian.demo2;
/**
* 编写电脑测试类,创建电脑对象,调用方法输出所有信息
* 创建电脑对象,完成对所有属性赋值,并调用方法输出电脑信息
*/
public class Test {
public static void main(String[] args) {
//创建电脑对象
Computer c = new Computer();
//调用方法输出所有信息
c.print();
System.out.println("--------------");
//创建电脑对象
Computer c2 = new Computer();
//完成对所有属性赋值
c2.color = "黑色";
c2.size = 15.6;
c2.price = 5688;
c2.memory = "16G";
c2.brand = "Lenovo";
//并调用方法输出电脑信息
c2.print();
}
}
Dog类
package com.jian.demo1;
public class Dog {
String nickName; //nickName就是成员变量
int age; //age就是成员变量
String breed; //breed就是成员变量
public void print(){
int a; //a就是局部变量
int b = 100; //b就是局部变量
double c; //c就是局部变量
for(int i = 1;i <= 5;i++){ //i就是局部变量
}
}
public void print2(){
System.out.println(nickName);
System.out.println(age);
System.out.println(breed);
}
public void print3(){
int num; //局部变量
// System.out.println(num); //出现编译错误,原因:局部变量没有默认值,必须先声明,然后再赋值,最后才可以使用
num = 123;
System.out.println(num);
}
public void print4(){
/*
总结:在同一个类中,局部变量的名字可以与成员变量的名字同名,不报错,但是局部变量优先,也就是就近的优先,如果非要访问成员变量,则必须使用this.
this代表当前这个对象,也就是说当前谁调用这个方法则这个对象就是谁
*/
String nickName = "旺财"; //nickName就是局部变量
System.out.println(nickName);
System.out.println("输出成员变量nickName的值:" + this.nickName);
}
}
测试类
package com.jian.demo1;
public class Test {
public static void main(String[] args) {
//创建Dog对象
Dog d = new Dog();
// d.print2();
// d.print3();
d.print4();
//创建第二个Dog对象
Dog dog1 = new Dog();
dog1.nickName = "二哈";
dog1.print4();
}
}
Car类
package com.jian.demo2;
public class Car {
//编写成员变量也叫做编写属性或者编写字段f
String id; //表示车牌号
String brand;
int price;
//编写方法
public void setId(String id){ //形参id属于局部变量,只能在当前方法中使用
//实现将形参的id值赋给成员变量id
//id = id; //注意:不报错,但是没有达到要求,目前实现的是形参id赋给形参id
//应该编写为:成员变量 = 局部变量;
this.id = id;
}
}
测试类
package com.jian.demo2;
public class Test {
public static void main(String[] args) {
//创建小轿车对象
Car c = new Car();
c.setId("京A12345");
System.out.println(c.id); //京A12345
System.out.println(c.brand); //null
System.out.println(c.price); //0
}
}
构造方法
package com.jian.demo3;
/**
* 构造方法:
* 1.构造方法作用:实现对象属性赋值
* 2.什么是构造方法?
* 构造方法是一个特殊的方法
* 构造方法的名字必须与类名一致
* 构造方法必须没有返回值类型,也就是都不需要编写void
* 3.构造方法语法格式
* public 类名([参数列表]){
* 完成对属性赋值
* }
* 4.快捷键生成构造方法
* 4.1光标放在类体中,按Alt + Insert键,选择第一项Constructor构造器回车,如果按两次Tab键,则生成无参构造方法
* 注意:大多数无参构造方法体中不编写任何内容
* 4.2光标放在类体中,按Alt + Insert键,选择第一项Constructor构造器回车,鼠标左键点击要赋值的属性,然后再按Ctrl + 鼠标左键点击其他要赋值的属性,再按回车,则生成带参构造方法,实现对部分属性赋值
* 4.3光标放在类体中,按Alt + Insert键,选择第一项Constructor构造器回车,按Ctrl + A全选,实现带参构造方法,完成对所有属性赋值的构造方法
* 5.构造方法如何执行?
* ----当创建对象时会自动找相匹配的构造方法执行
* 注意:1.当创建对象时小括号中没有内容,则执行无参构造方法
* 2.当创建对象时小括号中有内容,则执行相匹配的带参构造方法,否则出现编译错误
* 3.建议:当编写new,然后敲一个空格,编写类名的首字母,这时就可以按方向键进行选择执行哪个构造方法
* 4.当创建对象时没有选择执行哪个构造方法,则需要进行设置,具体如下:
* File--->Settings--->Editor--->General--->Code Completion--->右侧设置参数信息,将第一项和第三项勾上,点击OK
* 6.构造方法注意事项
* 6.1在一个类中,如果没有编写构造方法,则系统会提供一个默认的无参的构造方法,称为隐式构造方法
* 总结:一个类中不编写构造方法,则有一个无参的隐式的构造方法
* 6.2在一个类中,如果编写构造方法,则系统不会提供默认的无参的构造方法,称为显式构造方法
* 总结:在一个类中编写几个构造方法,则就有几个构造方法
* 6.3建议:当编写构造方法时,先编写无参构造方法,然后再编写需要的带参构造方法,否则可能会出现编译错误
* 7.构造方法重载
* 7.1什么是构造方法重载?
* 在同一个类中,构造方法的名字必须相同,参数列表必须不同(个数不同、类型不同、顺序不同),至少编写两个构造方法
* 7.2当构成构造方法重载以后,怎么知道要执行哪个构造方法?
* 在创建对象时,会自动找相匹配的构造方法执行,否则出现编译错误
* 7.3构造方法重载好处:
* 在使用时更灵活
*/
public class Student {
//编写属性也叫做编写成员变量或者字段
String name;
int age;
char gender;
double height;
double weight;
double score;
public void Student(){ //注意:不报错,但是不是构造方法,只是一个普通的方法
}
//编写无参构造方法
public Student() {
//完成对名字和年龄属性赋值
name = "无名氏";
age = 18;
}
//编写带参构造方法,实现对名字和分数赋值赋值
public Student(String name, double score) {
this.name = name;
this.score = score;
}
//编写带参构造方法,实现对名字、年龄、性别属性赋值
public Student(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//编写带参构造方法,实现对身高和体重属性赋值
public Student(double height, double weight) {
this.height = height;
this.weight = weight;
}
//编写带参构造方法,实现对年龄、性别、身高属性赋值
public Student(int age, char gender, double height) {
this.age = age;
this.gender = gender;
this.height = height;
}
//编写带参构造方法,实现对名字、年龄、性别、身高和体重属性赋值
public Student(String name, int age, char gender, double height, double weight) {
this.name = name;
this.age = age;
this.gender = gender;
this.height = height;
this.weight = weight;
}
//编写带参构造方法,实现对所有属性赋值的构造方法
public Student(String name, int age, char gender, double height, double weight, double score) {
this.name = name;
this.age = age;
this.gender = gender;
this.height = height;
this.weight = weight;
this.score = score;
}
//编写方法,实现输出学生的所有信息
public void print(){
System.out.println("姓名:" + name + "\n年龄:" + age + "\n性别:" + gender + "\n身高:" + height + "\n体重:" + weight + "\n分数:" + score);
}
}
测试类
package com.jian.demo3;
public class Test {
public static void main(String[] args) {
//创建学生对象
Student stu = new Student();
//第一种方法:实现对属性赋值,语法格式:对象名.属性名 = 值;
stu.name = "张浩";
stu.score = 98.5;
stu.weight = 76.4;
stu.height = 1.76;
stu.gender = '男';
stu.age = 19;
//调用方法
stu.print();
//第二种方法:实现对属性赋值,使用构造方法
}
}
package com.jian.demo3;
public class Test2 {
public static void main(String[] args) {
/*
1.创建学生对象同时执行无参构造方法,其实也就是小括号没有内容,则执行学生的无参构造方法
2.执行相匹配构造方法的代码如何编写?
当编写new,然后敲一个空格,编写类名的首字母,这时就可以按方向键进行选择,
当小括号中没有内容则执行无参构造方法
当小括号中有内容则执行相匹配的带参构造方法
3.当编写new,敲一个空格,然后编写类名首字母后没有提示要选择执行哪个构造方法,具体设置如下:
File--->Settings--->Editor--->General--->Code Completion--->右侧设置参数信息,将第一项和第三项勾上,点击OK
*/
/*Student s1 = new Student();
s1.print();*/
//创建学生对象同时执行带参构造方法,完成对名字和成绩属性赋值
/* Student s2 = new Student("莉莉", 89.7);
s2.print();*/
//创建学生对象同时执行带参构造方法,完成对
/*Student s3 = new Student(27, '女', 1.64);
s3.print();*/
//创建学生对象同时执行带参构造方法,完成对所有属性赋值
Student s4 = new Student("lisi", 23, '男', 1.77, 80.1, 92.5);
s4.print();
}
}
编写车类,属性:车牌号、品牌、颜色、价格,方法:输出车的信息
package com.jian.demo4;
/**
* 编写车类,属性:车牌号、品牌、颜色、价格,方法:输出车的信息
*
*/
public class Car {
//编写属性也叫做编写成员变量或者编写字段f
String id; //表示车牌号
String brand;
String color;
int price;
public Car() {
}
public Car(String id, String brand) {
this.id = id;
this.brand = brand;
}
public Car(String id, String brand, String color, int price) {
this.id = id;
this.brand = brand;
this.color = color;
this.price = price;
}
//方法:输出车的信息
public void print(){
System.out.println("车牌号:" + id + "\n品牌:" + brand + "\n颜色:" + color + "\n价格:" + price);
}
}
编写测试类,创建对象同时执行无参构造方法,并调用方法输出车的信息
创建对象同时执行带两个参数的构造方法,完成对车牌号和品牌赋值,并调用方法输出车的信息
创建对象同时执行带参构造方法完成对所有属性赋值,并调用方法输出车的信息
package com.jian.demo4;
/**
* 编写测试类,创建对象同时执行无参构造方法,并调用方法输出车的信息
* 创建对象同时执行带两个参数的构造方法,完成对车牌号和品牌赋值,并调用方法输出车的信息
* 创建对象同时执行带参构造方法完成对所有属性赋值,并调用方法输出车的信息
*
*/
public class Test {
public static void main(String[] args) {
//创建对象同时执行无参构造方法
Car c1 = new Car();
//并调用方法输出车的信息
c1.print();
System.out.println("------------------");
//创建对象同时执行带两个参数的构造方法,完成对车牌号和品牌赋值
Car c2 = new Car("辽A66666","大众" );
//并调用方法输出车的信息
c2.print();
System.out.println("------------------");
//创建对象同时执行带参构造方法完成对所有属性赋值
Car c3 = new Car("鲁A88888", "比亚迪", "黑色", 100000);
//并调用方法输出车的信息
c3.print();
}
}
编写猫类,属性:昵称,年龄,性别,无参构造,带参构造,输出猫的信息
package com.jian.demo5;
public class Cat {
//编写属性也叫做成员变量或者字段f
String nickName;
int age;
char gender;
public Cat() {
}
public Cat(String nickName, int age, char gender) {
this.nickName = nickName;
this.age = age;
this.gender = gender;
}
//编写方法,输出猫的信息
public void print(){
System.out.println("昵称:" + nickName + "\n年龄:" + age + "\n性别:" + gender);
}
}
编写测试类
package com.jian.demo5;
public class Test {
public static void main(String[] args) {
//int num = 18;
//上面一条语句,等价于如下写法:
/*int num; //表示声明一个整数类型局部变量名称num
num = 18;
num = -1;
num = 123;
String name;*/
//创建猫的对象同时执行无参构造方法
//Cat c = new Cat();
//上面一条语句,也可以编写为如下代码:
Cat c; //表示声明一个Cat类型的局部变量名c,其中Cat是一个自定义类的类名,在Java中可以使用类名作为数据类型
c = new Cat();
c.print();
System.out.println("----------------");
c = new Cat("小白", 3, '公');
c.print();
//也可以对对象名赋值为null
c = null;
/*
属于运行错误,空指针异常java.lang.NullPointerException
原因:当前对象名c中存放的是null,也就是说存放的不是地址,因此没有指向某个对象,所以就不能访问对象中的属性和对象中的方法,如果非要访问,则就出现空指针异常
*/
// c.print();
//解决办法:在访问对象中的属性或对象中的方法之前,必须保证对象名中存放的是地址,也就是指向某个对象,就可以访问对象中的属性或对象中的方法
System.out.println("-----------------------");
c = new Cat();
c.print();
}
}