1、设计对象并使用
(1)、类和对象。(在Java中,必须先设计类,才能获得对象。使用对象必须依赖于类,没有类就没有对象)
类:共同特征的描述。对于一类具有相同属性和行为的抽象,是一个抽象的概念看不见摸不着。
对象:是真实存在的具体案例。对象是类的一个具体呈现,是一个实实在在存在的事务。
(2)、如何定义类。
public calss 类名 {
1、成员变量(代表属性,一般是名词)
2、成员方法(代表行为,一般是动词)
3、构造器
4、代码块
5、内部类
}
例如以下:
public class Phone {
//属性(成员变量)
String brand;
double price;
int age = 0;
//行为(方法)
public void call(){
}
public void playGame(参数){
方法体语句;
return语句;
}
}
(3)、如何得到类的对象。
类名 对象名 = new 类名();
例如以下:
Phone p = new Phone();
(4)、如何使用对象。
1、访问属性:
对象名.成员变量 = 值; //为成员变量赋值
对象名.成员变量; //访问成员变量的值
2、访问行为:
对象名.方法名(实际参数);
(5)、设计对象并使用举例
package test;
public class Phone {
//属性
String brand;
double price;
//行为
public void call(){
System.out.println("手机在打电话");
}
public void playGame(){
System.out.println("手机在玩游戏");
}
}
package test;
public class PhoneTest {
public static void main(String[] args) {
//创建手机的对象
Phone p = new Phone();
//给手机赋值
p.brand = "小米";
p.price = 1999.98;
//获取手机中对象的值
System.out.println(p.brand);
System.out.println(p.price);
//调用手机中的方法即可
p.call();
p.playGame();
//创建第二个对象
Phone p2 = new Phone();
p2.brand = "苹果";
p2.price = 8999;
p2.call();
p2.playGame();
}
}
(6)、定义类的补充注意事项
a、类名首字母建议大写,用英文,需要见名知意,驼峰模式。不能用关键字,满足标志符规定。
b、一个Java文件中可以定义多个class类,但只能一个类是public修饰,而且public修饰的类名必须成为Java代码的文件名。(实际开发中建议还是一个文件定义一个class类)
c、成员变量的完整定义格式是:
修饰符 数据类型 变量名称 = 初始化值;
一般无需指定初始化值。存在默认值,默认值如下:
(7)、练习题(女朋友类)
编写女朋友类,创建女朋友类的对象,给女朋友的属性进行赋值并调用女朋友类中的方法。
package test02;
public class GrilFriend {
//属性
String name;
int age;
String gender;
//行为
public void sleep(){
System.out.println("女朋友在睡觉");
}
public void eat(){
System.out.println("女朋友在吃饭");
}
}
package test02;
public class GrilFriendTest {
public static void main(String[] args) {
GrilFriend gf1 = new GrilFriend();
gf1.name = "小红";
gf1.age = 18;
gf1.gender = "温柔";
System.out.println(gf1.name);
System.out.println(gf1.age);
System.out.println(gf1.gender);
gf1.sleep();
gf1.eat();
System.out.println("==============");
GrilFriend gf2 = new GrilFriend();
gf2.name = "小花";
gf2.age = 19;
gf2.gender = "可爱";
System.out.println(gf2.name);
System.out.println(gf2.age);
System.out.println(gf2.gender);
gf2.sleep();
gf2.eat();
}
}
扩展:选中内容,按住滚轮,往下拖,就可选中同一竖行的字母,进行同时修改
2、封装
1、对象代表什么,就得封装对应的数据,并提供数据对应的行为。
private关键字
(1)、是一个权限修饰符
(2)、可以修饰成员(成员变量和成员方法)
(3)、被private修饰的成员只能在本类中才能直接访问。在当前类之外,是不能直接被访问的。保证数据的安全性,不传递非法数据。
(4)、针对private修饰的成员变量,如果需要被其他类使用,需要提供相应的操作。
(5)、提供“setXxx(参数)”方法,用于给成员变量赋值,方法要用public修饰。
属性赋值的格式:
public void set+首字母大写的变量名(数据类型 参数名){
变量名 = 参数名;
}
例如:
public void setName(String n){
name = n;
}
(6)、提供“getXxx()”方法,用于获取成员变量的值,方法要用public修饰。
属性值获取的格式:
public 返回值类型 get+首字母大写的变量名(){
return 变量名;
}
例如:
public String getName(){
return name;
}
(7)、private可以修饰的内容有:成员变量、成员方法、构造方法、内部类。
例如:
public class GrilFriend {
private String name;
private int age;
private String gender;
}
前面加上private后,测试类main方法在访问的时候,系统就会报错。
2、如何让实现封装
具体的实现过程是,在定义一个类时,将类中的属性私有化,即使用private关键字来修饰,私有属性只能在它所在的类中被访问,如果外界想要访问私有属性,需要提供一些public修饰的公有方法,其中包含用于获取属性值的getXxx()方法 和 设置属性值的setXxx()方法。
package test02;
public class GrilFriend {
//属性
private String name;
private int age;
private String gender;
//针对于每一个私有化的成员变量,都要提供get和set方法
//set方法:给成员变量赋值
//get方法:对外提供成员变量的值
//作用:给成员变量name进行赋值
public void setName(String n){ //无返回值类型,所以用void
name = n;
}
//作用:对外提供name属性
public String getName(){ //return返回值类型为String
return name;
}
//age
//setAge:给成员变量age进行赋值
//getAge:对外提供成员变量age的值
public void setAge(int a){ //无返回值类型,所以用void
if(a >= 18 && a <= 50){
age = a;
} else {
System.out.println("非法参数");
}
}
public int getAge(){ //return返回值类型为int
return age;
}
//gender
public void setGender(String g){ //无返回值类型,所以用void
gender = g;
}
public String getGender(){ //return返回值类型为String
return gender;
}
//行为
public void sleep(){
System.out.println("女朋友在睡觉");
}
public void eat(){
System.out.println("女朋友在吃饭");
}
}
package test02;
public class GrilFriendTest {
public static void main(String[] args) {
GrilFriend gf1 = new GrilFriend();
//赋值
gf1.setName("小红");
gf1.setAge(18);
gf1.setGender("温柔");
String gf1name = gf1.getName();
System.out.println(gf1name);
System.out.println(gf1.getAge());
System.out.println(gf1.getGender());
gf1.sleep();
gf1.eat();
}
}
3、补充内容
public | 公开的,任意类皆可访问,不推荐,违背了封装 |
protected | 受保护的,本类,子类,同包皆可访问 |
private | 私有化,本类可访问,子类也不能访问 |
default(默认值) | 同包中可以访问 |
3、就近原则和this关键字
3.1、 就近原则:
① 当访问某个变量的时候,会在访问这条语句所在的大括号中寻找,有没有定义此变量,如果找到了就用,如果没有找到,就会到括号外去寻找,如果找到了就用,找不到就报错
② 当成员变量和局部变量同名的时候,访问变量就看谁距离访问的这个语句更近,就使用谁的数据
3.2、 this关键字
① 表示本类当前对象的引用
② 哪个对象调用this所在的方法,this就表示哪个对象
③ 作用:可以区分同名的成员变量和局部变量,this.变量名 代表访问的是成员变量,不加this的一般都是局部变量
3.3、成员变量和局部变量(遵循就近原则)
public class GrilFriend{
private int age = 15;
public void method(){
int age = 10;
System.out.println(age); //输出结果为10
System.out.println(this.age); //输出结果为15
}
}
添加this后访问的是成员变量,不添加this访问时遵循就近原则,访问局部变量
this用来区分成员变量和局部变量
package test02;
public class GrilFriend {
//属性
private String name;
private int age;
private String gender;
public void setName(String name){
//等号右边,局部变量,表示测试类中调用方法传递过来的数据
//等号的左边,表示成员位置的name
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
if(a >= 18 && a <= 50){
this.age = age;
} else {
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
public void setGender(String gender){
this.gender = gender;
}
public String getGender(){
return gender;
}
}
4、构造方法
构造方法也叫构造器,构造函数。作用是:在创建对象的时候给成员变量进行赋值的。
1、构造方法的格式:
public class Student{
修饰符 类名(参数){
方法体;
}
}
特点:
1、方法名和类名相同,大小写也要一致。
2、没有返回值类型,连void都没有。
3、没有具体的返回值(不能由return带回结果数据。构造方法可以有return,但是只能写 return; 表示结束方法)
4、修饰符可以是public、private,private修饰的就是私有的构造方法,public修饰的就是公开的构造方法
举例如下:
public class Student{
private String name;
private int age;
public Student(){
//空参构造方法
}
public Student(String name,int age){
//带全部参数构造方法
}
}
执行时机:
1、创建对象的时候由虚拟机调用,不能手动调用构造方法。
2、每创建一次对象,就会调用一次构造方法。
3、不能使用对象名调用构造方法。
2、举例如下:
package test02;
public class GrilFriend {
private String name;
private int age;
//如果我们自己没有写任何构造方法,虚拟机会给我们一个无参数的构造
//无参数的构造
public GrilFriend(){
System.out.println("我有没有被执行呢");
}
//有参数的构造
public GrilFriend(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//set和构造方法的区别
//set方法主要用于创建对象完成之后,后期修改对象的属性值
//构造方法主要是创建对象的同时,给对象赋值属性值
}
package test02;
public class GrilFriendTest {
public static void main(String[] args) {
//创建对象调用无参数的构造
GrilFriend gf1 = new GrilFriend();
gf1.setName("小红");
gf1.setAge(25);
System.out.println(gf1.getName());
System.out.println(gf1.getAge());
//调用有参数的构造
GrilFriend gf2 = new GrilFriend("小丽",23);
System.out.println(gf2.getName());
System.out.println(gf2.getAge());
}
}
输出结果为:
我有没有被执行呢
小红
25
小丽
23
3、构造方法注意事项:
1、构造方法的定义
如果没有构造方法,系统将会给出一个默认的无参数构造方法。
如果定义了构造方法,系统将不再提供默认的构造方法。
2、构造方法的重载
带参构造方法,和无参构造方法,两者方法名相同,但是参数不同,这叫做构造方法的重载。
3、推荐使用的方式
无论是否使用,都手动书写无参构造方法,和带全部参数的构造方法。
4、一般的类中,既要有空参构造,也要有全参构造,都是手动定义出来的
4、小结
1、构造方法的作用?
创造对象的时候,由虚拟机自动调用,给成员变量进行初始化的。
2、构造方法有几种?各自的作用是什么?
无参数构造方法:初始化对象时,成员变量的数据均采用默认值。
有参数构造方法:在初始化对象的时候,同时可以为对象进行赋值。
3、构造方法有哪些注意事项?
任何类定义出来,默认就自带了无参构造器,写不写都有。
一旦定义了有参数构造器,无参数构造器就没有了,此时就需要自己写无参数构造器了。
建议在任何时候都手动写上空参和带全部参数的构方法。
5、标准的Javabean类
1、类名需要见名知意。
2、成员变量使用private修饰。
3、提供至少两个构造方法。(无参构造方法;带全部参数的构造方法)
4、成员方法。
提供每一个成员变量对应的setXxx()/getXxx()
如果还有其他行为,也要写上。
package test03;
public class User {
//属性
private String username;
private String password;
private String email;
private String gender;
private int age;
//空参
//快捷方式:Alt+insert->constructor(构造函数)->select None(取消选择)
//快捷方式也可以为Alt+Fn+insert
public User() {
}
//带全部参数的构造
//快捷方式:Alt+insert->constructor(构造函数)->Ctrl+A全选->OK
//快捷方式也可以为Alt+Fn+insert
public User(String username, String password, String email, String gender, int age) {
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
//getXxx()和setXxx()方法
//快捷方式:Alt+insert->Getter and Setter->Ctrl+A全选->OK
//快捷方式也可以为Alt+Fn+insert
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/**补充:插件PTG 1秒生成Javabean
* file->setting->plugins->Marketplace->搜索ptg->OK
* 在代码书写界面,右击鼠标,选择Ptg To JavaBean进行点击即可
* 会同时生成空参构造、全参构造、get和set方法
*/
Javabean相关的快捷方式:
1、生成空参构造方法
//快捷方式:Alt+insert->constructor(构造函数)->select None(取消选择)
//快捷键也可以为Alt+Fn+insert
2、生成带全部参数的构造
//快捷方式:Alt+insert->constructor(构造函数)->Ctrl+A全选->OK
//快捷键也可以为Alt+Fn+insert
3、生成getXxx()和setXxx()方法
//快捷方式:Alt+insert->Getter and Setter->Ctrl+A全选->OK
//快捷键也可以为Alt+Fn+insert
4、补充:插件PTG 1秒生成Javabean
* file->setting->plugins->Marketplace->搜索ptg->OK
* 在代码书写界面,右击鼠标,选择Ptg To JavaBean进行点击即可
* 会同时生成空参构造、全参构造、get和set方法
6、三种情况的对象内存图
7、基本数据类型和引用数据类型
8、this的内存原理
9、成员和局部
成员变量的初始化值默认如下:
引用数据类型: null
整数 0
小数 0.0
字符 \u0000
布尔 false