我要评论对象和类
类的定义
- java程序至少由一个或一个以上的类构成，但只有一个公有类，即使用public关键字修饰的类的名称必须跟和程序文件名称一致。
- 类是由方法成员和数据成员组成
使用类创建对象
创建对象
创建对象的内存分配
实例
/*
定义类,一个java程序可以定义多个类，但只能定义一个与程序名称相同的公有类
[修饰符] class 类名{
数据成员；
.
.
.
方法成员；
.
.
.
}
*/
class student{
int age;
string name;
char gender;
double score;
void msgprintf(){
system.out.println("name is " + name);
system.out.println("age is " + age);
system.out.println("gender is " + gender);
system.out.println("score is " + score);
}
}
public class demo1 {
public static void main(string[] args) {
//创建对象
//方式1：先声明再使用new关键字创建
student s1; //声明某个对象属于某个类：类名 对象名;
s1 = new student(); //使用new关键字创建对象
s1.age = 20;
s1.name = "jiangxiaoya";
s1.gender = '女';
s1.score = 99.9;
s1.msgprintf();
system.out.println();
//方式2：声明对象的同时并使用new关键字创建对象
student s2 = new student();
s2.age = 21;
s2.name = "haozige";
s2.gender = '男';
s2.score = 66.6;
s2.msgprintf();
system.out.println();
//方式3：不声明对象，直接使用new关键字,该方式无法向方法传参
new student().age = 18;
new student().name = "zhutoucai";
new student().gender = '女';
new student().score = 88.8;
new student().msgprintf();
}
}
类的成员封装
public公有封装
- 定义类时，类的数据成员或方法成员使用public关键字修饰
- 这种封装下的成员允许任何类访问
private私有封装
- 定义类时，类的数据成员或方法成员使用private关键字修饰
- 这种封装下的成员只允许自身所在的类进行访问，其他类不能访问
protected保护封装
- 定义类时，类的数据成员或方法成员使用protected关键字修饰
- 这种封装下的成员只允许自身所在的类或者继承自身类的子类或者同一个包中的类进行访问，其他类不能访问
不进行封装
- 定义类时，类的数据成员或方法成员不使用任何关键字修饰
- 同一个包中的类能进行访问
实例
class student{
//private关键字，只有该类才能访问，私有成员
//public关键字，该类或非该类均可以访问，公有成员
//protected关键字，该类及其子类的成员可以访问，同一个包中的类也可以访问
//默认，同一个包中的类可以访问
private int age; //私有成员
protected string name; //保护成员
char gender;
double score;
void msgprintf(){
system.out.println("name is " + name);
system.out.println("age is " + age);
system.out.println("gender is " + gender);
system.out.println("score is " + score);
}
void inputage(){
age = 21;
}
}
public class demo1 {
public static void main(string[] args) {
student s2 = new student();
//s2.age = 21; 由于student类中的数据成员age是私有成员，因此不能直接访问它
s2.inputage(); //间接访问私有成员
s2.name = "haozige"; //同一个包中的类也能访问保护成员
s2.gender = '男';
s2.score = 66.6;
s2.msgprintf();
system.out.println();
}
}
构造方法
构造方法主要用于在使用new关键字创建对象时同时传递参数进行数据成员的初始化
定义构造方法
构造方法在定义类中定义
类名称(参数列表){
赋值语句；
}使用构造方法
类名称 对象名 = new 类名称(参数列表)
实例
class student{
private int age; //即使是私有成员，在创建对象时一样能进行初始化
string name;
char gender;
double score;
void msgprintf(){
system.out.println("name is " + name);
system.out.println("age is " + age);
system.out.println("gender is " + gender);
system.out.println("score is " + score);
}
//构造方法1
student(int newage,string newname,char newgender,double newscore){
age = newage;
name = newname;
gender = newgender;
score = newscore;
}
//构造方法一样可以进行方法重载
student(int newage,string newname){
age = newage;
name = newname;
}
}
public class demo3 {
public static void main(string[] args) {
//创建对象时想同时传递参数进行数据成员的初始化时可以使用构造方法
student s1 = new student(21,"haozige",'男',66.6); //对应定义类student的构造方法1
s1.msgprintf();
system.out.println();
student s2 = new student(20,"jiangxiaoya"); //对应定义类student的构造方法2
s2.msgprintf();
}
}
this关键字
- this关键字调用本类数据成员或者方法
- this关键字在构造方法首条语句调用其他构造方法
- this关键字解决方法中数据成员变量命名冲突的问题
- this关键字看作一个变量时，值为调用此方法的对象
实例
class student{
int age;
string name;
int sex;
double sorce;
//构造方法1
student(){
system.out.println("我是构造方法1");
}
//构造方法2（方法重写）
student(int age,string name,int sex,double sorce){
this(); //在构造方法中使用this关键字调用其他构造方法
//this关键字解决形参同名的问题
this.age = age;
this.name = name;
this.sex = sex;
this.sorce = sorce;
}
void msgprintf(){
system.out.println(this.age); //this关键字调用本类的数据成员或者方法
}
void myprintf(){
this.msgprintf(); //this关键字调用本类的数据成员或者方法
//this关键字看作一个变量，值为为调用此方法的对象
student stutmp = this;
system.out.println(stutmp.name);
}
}
public class text {
public static void main(string[] args) {
student stu1 = new student(20,"jiangxiaoya",0,99.5);
stu1.myprintf();
}
}
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。
发表评论