java类和对象实例,java面向对象编程实例

　　00-1010类和对象的关系类和对象的实例化静态关键字封装私有实现的构造方法此关键字代码块匿名对象摘要

　　public class test moder { public static void main(String[]args){ Person Person 1=new Person()；Person1.name=张三；person1.age=18system . out . println(person 1 . name)；system . out . println(person 1 . age)；person 1 . eat()；Person person2=新人()；Person2.name=李四；person2.age=20system . out . println(person 2 . name)；system . out . println(person 2 . age)；person 2 . eat()；} } class Person { public String name；公共int agepublic void eat(){ system . out . println( eat )；}}定义在类中的变量可以称为“字段”/“属性”/“成员变量”，定义在类中的方法称为成员方法。我们可以知道一个类可以实例化多个对象，每个对象都有一个公共的成员变量。

　　用类类型创建对象的过程称为类的实例化。

　　1.一个类就像一个模型，它定义了一个类拥有哪些成员。

　　2.一个类可以实例化多个对象，实例化的对象占用实际的物理空间，存储类成员变量。

　　00-1010成员变量分为普通成员变量和静态成员变量。上面已经提到了普通的成员变量——公共字符串名；Name是一个普通的成员变量，用static修饰后就成了静态成员变量。公共静态字符串name，name成为一个静态成员变量。这里有一个例子：

　　public class test moder { public static void main(String[]args){ Person Person 1=new Person()；person1 .年龄；Person.highsystem . out . println(person 1 . age)；system . out . println(person . high)；人员人员2=ne

　　w Person(); person2.age++; Person.high++; System.out.println(person2.age); System.out.println(Person.high); }} class Person { public int age; public static int high; public void eat() { System.out.println("吃饭"); } }

　　注意：静态成员变量不可以放在其他方法中定义，静态变量属于类，不属于对象。

　　默认值：

　　static修饰的成员变量叫静态成员变量，static修饰的方法成为静态方法。

　　1、静态方法属于类，而不属于类的对象。

　　2、可以直接调用静态方法，而无需创建类的实例。

　　3、静态方法可以访问静态数据成员，并可以更改静态数据成员的值

　　4、静态方法内部不可以调用其他方法，但是其他方法内部可以调用静态方法。

　　看个例子：

 public static void main(String[] args) { Test.change();//无需创建实例对象 就可以调用 System.out.println(Test.count); }}class Test{ public int a; public static int count; public static void change() { count = 100; //a = 10; error 不可以访问非静态数据成员 }}

//结果为100

　　

private实现的封装

什么叫封装：

　　<< 代码大全 >> 开篇就在讨论一个问题 : 软件开发的本质就是对程序复杂程度的管理 . 如果一个软件代码复杂程度太高 , 那么就无法继续维护。如何管理复杂程度 ? 封装就是最基本的方法。在我们写代码的时候经常会涉及两种角色 : 类的实现者和类的调用者 . 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的 , 只要知道如何使用类就行了 .这样就降低了类使用者的学习和使用成本 , 从而降低了复杂程度。

　　private实现的封装：

　　private/ public 这两个关键字表示 " 访问权限控制 " .

　　被 public 修饰的成员变量或者成员方法 , 可以直接被类的调用者使用 .

　　被 private 修饰的成员变量或者成员方法 , 不能被类的调用者使用 .

　　换句话说 , 类的使用者根本不需要知道 , 也不需要关注一个类都有哪些 private 的成员。从而让类调用者以更低的成本来使用类。

　　看个例子：

public class TestModer { public static void main(String[] args) { Person person = new Person(); person.show(); }}class Person{ private String name = "张三"; private int age = 18; public void show() { System.out.println("我叫" + name + ", 今年" + age + "岁"); }}

　　此时字段已经使用 private 来修饰 . 类的调用者 (main 方法中 ) 不能直接使用 . 而需要借助 show 方法。此时类的使用者就不必了解 Person 类的实现细节。同时如果类的实现者修改了字段的名字 , 类的调用者不需要做出任何修改 ( 类的调用者根本访问不到 name, age 这样的字段 )。

　　注意：

　　1、private 不光能修饰字段 , 也能修饰方法

　　2、通常情况下我们会把字段设为 private 属性 , 但是方法是否需要设为 public, 就需要视具体情形而定。一般我们希望一个类只提供 " 必要的 " public 方法 , 而不应该是把所有的方法都无脑设为 public。

　　现在有一个问题类的实现者万一修改了 public 方法 show 的名字 , 岂不是类的调用者仍然需要大量修改代码嘛 ?

　　这个时候我们就来看看 getter 和 setter 方法。

　　getter 和 setter 方法的使用：

public class TestModer { public static void main(String[] args) { Person person = new Person(); person.setName("张三"); String name = person.getName(); System.out.println(name); person.show(); }}class Person{ private String name;//实例成员变量 private int age; public void setName(String name){ //name = name;//不能这样写 this.name = name;//this引用，表示调用该方法的对象 } public String getName(){ return name; } public void show(){ System.out.println("name: "+name+" age: "+age); }}

　　字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用，这时候我们可以借助getter和setter来使用，getName 即为 getter 方法, 表示获取这个成员的值。setName 即为 setter 方法, 表示设置这个成员的值。getter和setter可以不用手动输入，可以在类中点击右键按下图操作：

　　在这里我们是调用了show这个方法来实现打印，如果不调用方法，可以自带的to String进行打印。

　　to String用法：

public class TestModer { public static void main(String[] args) { Person person = new Person(); person.setName("张三"); String name = person.getName(); System.out.println(name); //person.show(); System.out.println(person); } } class Person{ private String name;//实例成员变量 private int age; public void setName(String name){ //name = name;//不能这样写 this.name = name;//this引用，表示调用该方法的对象 } public String getName(){ return name; } //public void show(){ //System.out.println("name: "+name+" age: "+age); //} @Override public String toString() { return "Person{" + "name=" + name +  + ", age=" + age + }; } }

　　toString 方法会在 println 的时候被自动调用，将对象转成字符串这样的操作我们称为序列化 . toString 是 Object 类提供的方法 , 我们自己创建的 Person 类默认继承自 Object 类 , 可以重写 toString 方法实现我们自己版本的转换字符串方法。快速生成toString的方法：在类中点击鼠标右键，按下图操作：

构造方法

构造方法是一种特殊方法 , 使用关键字 new 实例化新对象时会被自动调用 , 用于完成初始化操作。

　　new 执行过程

　　为对象分配内存空间调用对象的构造方法语法规则

　　1.方法名称必须与类名称相同

　　2.构造方法没有返回值类型声明

　　3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

　　举个例子：

public class TestModer { public static void main(String[] args) { Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数 p1.show(); Person p2 = new Person("张三",80,"男");//调用带有3个参数的构造函数 p2.show(); }}class Person { private String name;//实例成员变量 private int age; private String sex; //默认构造函数 构造对象 public Person() { this.name = "王五"; this.age = 10; this.sex = "男"; } 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); }}

　　注意事项：

　　如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数。

　　若类中定义了构造方法，则默认的无参构造将不再生成。

　　构造方法支持重载，规则和普通方法的重载一致。

this关键字

this 表示当前对象引用 ( 注意不是当前对象 ). 可以借助 this 来访问对象的字段和方法

　　this有三种用法：

　　1、this.date-->调用当前对象的属性。

　　2、this.func()-->调用当前对象的方法。

　　3、this（）-->调用当前对象的其他构造方法。

　　前面两种方法我们之前都用过了，接下来我们来看看第三种用法。

class Person { private String name;//实例成员变量 private int age; private String sex; //默认构造方法 构造对象 public Person() { //this调用构造函数 this("bit", 12, "man");//必须放在第一行进行显示 } //这两个构造方法之间的关系为重载。 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 person = new Person();//调用不带参数的构造方法 person.show(); }

运行结果：

　　注意：this（）必须放在第一行！！！否则会报错。

代码块

字段的初始化方式有：

　　1. 就地初始化

　　2. 使用构造方法初始化

　　3. 使用代码块初始化

　　前两种方式前面已经看过了 , 接下来我们介绍第三种方式 , 使用代码块初始化。

　　代码块可以分为四种：

　　1、普通代码块（也称本地代码块）

　　2、构造代码块（也称实例化代码块）

　　3、静态代码块

　　4、同步代码块

　　我们在这里主要认识第二种和第三种。

　　1、普通代码块

　　定义在方法中

 public static void main(String[] args) { { //直接使用{}定义，普通方法块 int x = 10; System.out.println("x1 = " + x); } }}

2、构造代码块

　　构造块：定义在类中的代码块 ( 不加修饰符 ) 。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person { private String name; private int age=19; public static int count; //构造代码块 { this.age = 99; System.out.println("构造代码块！"); }

3、静态代码块

　　使用 static 定义的代码块。一般用于初始化静态成员属性。

class Person { private String name; private int age = 19; public static int count;//0 //静态代码块 static { count = 99; System.out.println("静态代码块！"); }}

注意：

　　1、静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

　　2、静态代码块执行完毕后 , 实例代码块（构造块）执行，再然后是构造函数执行。

匿名对象

1、匿名只是表示没有名字的对象 .

　　2、没有引用的对象称为匿名对象 .

　　3、匿名对象只能在创建对象时使用 .

　　4、如果一个对象只是用一次 , 后面不需要用了 , 可以考虑使用匿名对象。

　　来看个例子：

class Person { private String name; private int age; public Person(String name,int age) { this.age = age; this.name = name; } public void show() { System.out.println("name:"+name+" " + "age:"+age); } } public class Main { public static void main(String[] args) { new Person("caocao",19).show();//通过匿名对象调用方法//Person person=new Person();//非匿名对象 } }

小结

以上就是类和对象的使用，一个类可以产生无数的对象，类就是模板，对象就是具体的实例。类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。静态代码块优先实例代码块执行，实例代码块优先构造函数执行。 this关键字代表的是当前对象的引用。并不是当前对象。如果有什么不正确的地方大家尽管说哦！

　　到此这篇关于Java全面细致讲解类与对象的文章就介绍到这了,更多相关Java类与对象内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

java类和对象实例,java面向对象编程实例

目录

private实现的封装

构造方法

this关键字

代码块

匿名对象

小结

相关文章阅读