脚本宝典收集整理的这篇文章主要介绍了【Java系列】类和对象中需要注意的事情,脚本宝典觉得挺不错的,现在分享给大家,也给大家做个参考。
类和对象是面向对象编程语言的重要概念。Java是一种面向对象的语言,所以要想熟练使用Java,就一定要掌握类和对象的使用。
【类的概念】
将具有相同属性及相同行为的一组对象称为类(class)。
广义地讲,具有共同性质的事物的集合就称为类。
在面对对象程序设计中,类是一个独立的单位,它有一个类名,其内部包含成员变量,用于描述对象的属性F1b;还包括类的成员方法,用于描述对象的行为。
如下:
class PErson{
String name;//变量
int age;//变量
void talk(){//操作数据的方法
System.out.println("我是:"+name+",今年:"+age+"岁");
}
}
【概念】
对象(object)是类的实例化后的产物
一个对象由一组属性和一系列对属性进行操作的方法构成。
在Java中,一切皆为对象。
类是对某一类事物的描述,是抽象的、概念上的定义; 对象是实际存在在该类事物的个体。也可称为实例。
举个例子: 我们需要图纸来造出椅子,这个图纸就是“类”,而由图纸设计出来的椅子就称为“对象”。
声明一个类就是创建一个新的数据类型,而类在 Java 中属于引用类型, Java 使用关键字 class 来声明类。我们来 看以下简单的声明一个类。
【基本语法】
// 创建类
[标识符]class 类名称{
field;//成员属性
method;//成员方法
}
// 实例化对象
类名称 <对象名> = new 类名称();
标识符可以是public、private、protected。class为定义类的关键字,{}中为类的主体。 类中的元素称为:成员属性。类中的函数称为:成员方法。
类的定义:
class Person {
public int age;//成员属性 实例变量
public String name;//定义人的姓名
public String sex;//性别
public void eat() {//成员方法
System.out.println("吃饭!");
}
public void sleep() {//成员方法
System.out.println("睡觉!");
}
}
【注意】这里在定义方法是没有使用到static关键字。后面我们会详细介绍static关键字。
类的实例化:
class Person {
public int age;//成员属性 实例变量
public String name;
public String sex;
public void eat() {//成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
public class testDemo{
public static void main(String[] args) {
Person person = new Person();//通过new实例化对象
person.eat();//成员方法调用需要通过对象的引用调用
person.sleep();
//产生对象 实例化对象
Person person2 = new Person();//可创建多个对象
Person person3 = new Person();
}
}
对象实例化的过程如下图:
在程序中用static定义属性的化,则此变量称为静态属性。
那什么是静态属性?使用静态属性又有什么好处呢?
看下面代码:
class Person{//定义Person类,有3个属性,name,age,cITy
String name;
String city;
int age;
public Person(String name,String city,int age){//定义构造方法
this.name=name;
this.city=city;
this.age=age;
}
public String talk(){//定义talk方法
return "我是:"+this.name+",今年:"+this.age+"岁,来自:"+this.city;
}
}
public class TestDemo{
public static void main(String[] args) {
Person p1=new Person("张三","中国",25);//实例化Person对象
Person p2=new Person("李四","中国",25);
Person P3=new Person("王五","中国",25);
System.out.println(p1.talk());//调用talk()方法输出信息
System.out.println(p2.talk());
System.out.println(p3.talk());
}
}
观察发现,所有的Person对象都有一个city属性,而且所有属性都相同,为中国。
如果我们程序中有100个Person对象,想要改变city属性,是不是要调用100次,这就太麻烦了。
所以我们可以用static关键字来解决这个问题,用它来修饰类的属性后,则此属性就是共同属性了。 修改如下:
class Person{//定义Person类,有3个属性,name,age,city
String name;
static String city;//static修饰
int age;
public Person(String name,String city,int age){//定义构造方法
this.name=name;
this.city=city;
this.age=age;
}
public String talk(){//定义talk方法
return "我是:"+this.name+",今年:"+this.age+"岁,来自:"+this.city;
}
}
public class TestDemo{
public static void main(String[] args) {
Person p1=new Person("张三","中国",25);//实例化Person对象
Person p2=new Person("李四","中国",25);
Person p3=new Person("王五","中国",25);
System.out.println("修改前的信息"+p1.talk());//调用talk()方法输出信息
System.out.println("修改前的信息"+p2.talk());
System.out.println("修改前的信息"+p3.talk());
System.out.println("=================================");
p1.city="美国";
System.out.println("修改后的信息"+p1.talk());//调用talk()方法输出信息
System.out.println("修改后的信息"+p2.talk());
System.out.println("修改后的信息"+p3.talk());
}
}
static修饰的属性中,同一个类的不同实例共用同一个静态属性.
如果在任何方法上应用 static 关键字,此方法称为静态方法
例子如下:
class Person{//定义Person类,有3个属性,name,age,city
String name;
static String city;//定义静态属性city
int age;
public Person(String name,String city,int age){//声明一个构造方法
this.name=name;
this.city=city;
this.age=age;
}
public String talk(){//定义talk方法
return "我是:"+this.name+",今年:"+this.age+"岁,来自:"+this.city;
}
public static void setCity(String c){//声明一个静态方法
city.c;
}
}
public class TestDemo{
public static void main(String[] args) {
Person p1=new Person("张三","中国",25);//实例化Person对象
Person p2=new Person("李四","中国",25);
Person p3=new Person("王五","中国",25);
System.out.println("修改前的信息"+p1.talk());//调用talk()方法输出信息
System.out.println("修改前的信息"+p2.talk());
System.out.println("修改前的信息"+p3.talk());
System.out.println("=================================");
p1.city="美国";
System.out.println("修改后的信息"+p1.talk());//调用talk()方法输出信息
System.out.println("修改后的信息"+p2.talk());
System.out.println("修改后的信息"+p3.talk());
}
}
此外:
封装是什么?
封装是将描述某类事物的数据与处理这些数据的函数封装在一起,形成一个整体,称为类。
一旦设计好类,就可以实例化该类的对象。我们在形成一个对象的同时也界定了对象与外界的内外界限。
对象的属性、行为等实现的细节则被分装在对象的内部。外部使用者和其他对象只能经由原先规划好的接口与对象交互。
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度
private/ public 这两个关键字表示 “访问权限控制” .
被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.
换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类。
以一只猫的例子来举例:
class Mycat{
public float weight; //通过public修饰符,开放MyCat的属性给外界
Mycat(){}
}
class TestDemo{
public static void main(String[] args) {
Mycat aCat=new Mycat();
aCat.weight=-10.0f; //设置Mycat的属性值
float tmp=aCat.weight;//获取Mycat的属性值
System.out.println("这只猫的体重是:"+tmp);
}
}
这里就需要用到Setter和Getter方法了。
通常
我们下面尝试用这两个方法修改猫的体重:
class Mycat{
private float weight; //通过private修饰符,开放MyCat的属性给外界
public void SetWeight(float wt){
if(wt>0){
this.weight=wt;
}else {
System.out.println("weight设置非法(应该>0)");
weight=10.0f;
}
}
public float GetWeight(){
return weight;
}
}
class TestDemo{
public static void main(String[] args) {
Mycat aCat=new Mycat();
aCat.SetWeight(-10f); //设置Mycat的属性值
float tmp=aCat.GetWeight();//获取Mycat的属性值
System.out.println("这只猫的体重是:"+tmp);
}
}
构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作。
声明对象并实例化的格式:
类名称 对象名称=new 类名称();
所谓构造方法,就是在每一个类中定义的,并且实在使用关键字new实例化一个新对象的时候默认调用的方法。
class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
this.name = "caocao";
this.age = 10;
this.sex = "男";
}
//带有3个参数的构造函数
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main{
public static void main(String[] args) {
Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
p1.show();
Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
p2.show();
}
}
// 执行结果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex: 男
使用构造方法需要注意以下几点:
使用this关键字,只需遵循一个原则,就是this表示当前对象,而所谓的当前对象就是指调用类中方法或属性的那个对象。
代码块用{ }将多行代码封装在一起,形成一个独立的代码区域。 格式如下:
{ //代码块 }
代码块有四种:
代码块不能独立运行,需要依赖于其他配置
普通代码块是最常见的代码块,它不能单独存在于类中,需要紧跟在方法名后面,并通过方法调用。
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
构造代码块就是在类中直接定义的,且没有任何前缀,后缀以及修饰符的代码块。 前面提到,在一个类中,至少需要有一个构造方法,如果没有,编译器就会“隐式”地配备一个。
private String name;//实例成员变量
private int age;
private String sex;
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = ";man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}
// 运行结果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man
【注意】
构造代码块不在任何方法之内,仅位于类的范围内,它的地位与其他方法体是对等的,可以理解为构造代码块是没有名称的方法体,但仅限用于对类数据成员的初始化,且仅运行一次。 此外,在类被实例化的过程中,构造代码块内的代码比构造方法先执行。
使用static关键字加以修饰的代码块就是静态代码块。其主要用来初始化成员变量。它是最早执行的代码块。
private String name;//实例成员变量
private int age;
private String sex;
private static int count = 0;//静态成员变量 由类共享数据 方法区
public Person(){
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
//静态代码块
static {
count = 10;//只能访问静态数据成员
System.out.println("I am static init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();//静态代码块是否还会被执行?
}
}
【结论】
最近学习有点落下了,编程的学习还是在于写,要刷题,而自己在这方面确实很匮乏。一方面是最近考试多,要备考;一方面是参加了比赛,要备赛。每天像一个猴子一样蹦蹦跳跳,还以为自己积极向上,哈哈哈哈哈…
以上是脚本宝典为你收集整理的【Java系列】类和对象中需要注意的事情全部内容,希望文章能够帮你解决【Java系列】类和对象中需要注意的事情所遇到的问题。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。