Java面向对象编程
类与对象
面向对象，是最为流行的软件设计与开发方法，Java本身最大的特点是属于面向对象的编程语言，在面向对象中两个基本成员：类、对象
一、面向对象
面向对象有三个主要特征：封装性、继承性和多态性后面会对此逐一解释
二、类与对象
先定义类结构，再通过对象来使用这个类
1、成员属性（field）：主要保存对象的具体特征。
2、方法（method）：用于描述功能。
1.类与对象的定义
类由成员属性和方法组成
范例：类的定义
public class fengzhuang {
String name;
int age;
/**
* 定义一个方法，获取输出内容
*/
public void tell(){
System.out.println("姓名："+name+"、年龄："+age);
}
}
现在还不能输出
Java引用数据类型，必须通过关键字new来，称为”实例化对象“
1、对象.成员属性：表示调用类中的成员属性，可以为其赋值或者获取其保存内容。
2、对象.方法（）：表示调用类中方法。
范例：通过实例化对象进行类操作：
public class fengzhuang {
public static void main(String[] args) {
Perxon perxon=new Perxon(); //实例化对象
perxon.age=18; //为成员属性赋值
perxon.name="张三"; //为成员属性赋值
perxon.tell(); //进行方法调用
}
}
class Perxon{
String name;
int age;
/**
* 定义一个方法，获取输出内容
*/
public void tell(){
System.out.println("姓名："+name+"、年龄："+age);
}
}
程序输出结果：
姓名：张三、年龄：18
成员属性封装
1、封装的概念:内部结构对外不可见在之前的操作中，需要实例化对象调用，但是不安全，最稳妥的做法是利用private进行封装操作。
setterandgetter方法
2、访问控制权限：
| 范围 | private | default | protected | public |
|---|---|---|---|---|
| 同一包的同一类 | √ | √ | √ | √ |
| 同一包的不同类 | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 不同包的非子类 | √ |
范例：使用private实现封装
public class Privte { //定义一个类
String name; //定义一个姓名
int age; //定义一个年龄
public String getName() {//设置name的属性
return name;
}
public void setName(String name) { //获取name的属性
this.name = name;
}
public int getAge() { //设置age的属性
return age;
}
public void setAge(int Age) { //获取age的属性
if (Age > 0 && Age < 250){ //适当添加一些逻辑
age = Age;
}
}
@Override
public String toString() { //对方法重写
return "Privte{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Test {
public static void main(String[] args) {
Privte privte=new Privte(); //实例化对象
privte.setAge(19); //调用set方法
privte.setName("张三");
privte.toString(); //调用重写
System.out.println(privte); // 输出
}
}
程序输出结果：
Privte{name='张三', age=19}
构造方法与匿名对象
1、构造方法是在类中定义的一种特殊方法，它在一个类使用关键字new实例化新对象时默认调用，其主要功能时完成对象属性的初始化操作。
格式：类名称 对象名称 = new 类名称();
1、类名称：对象所以功能必须有类定义，也就是说本操作是告诉程序所具有的功能。
2、对象名称：实例化对象的唯一标注，在程序之中利用此标注可以找到对象。
3、new：类属于应用数据类型，所以对象的实例化一定要用new来开辟堆内存空间。
4、类名称()：一般只有方法定义的时候才需要加上()，表示调用构造方法。
2、在Java语言中，类中构造方法的定义要求如下：
1、构造方法的名称和类名保持一致。
2、构造方法不允许有返回值类型声明。
3、关于默认构造方法
每一个类中至少会有一个构造方法，在没有声明的时候，系统会默认给予一个无参且无返回值的构造方法
范例：默认会存在一个无参的构造方法
class Preson{ //类名称首字母大写
public Preson(){ //无参无返回值的方法
}
}
范例：定义构造方法为属性初始化
class Privte1 { //定义一个类
String name; //定义一个姓名
int age; //定义一个年龄
public Privte1(String name, int age) { //构造方法
this.name = name;
this.age = age;
}
public String getName() {//设置name的属性
return name;
}
public void setName(String name) { //获取name的属性
this.name = name;
}
public int getAge() { //设置age的属性
return age;
}
public void setAge(int Age) { //获取age的属性
if (Age > 0 && Age < 250){ //适当添加一些逻辑
age = Age;
}
}
@Override
public String toString() {
return "Privte{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Privte{
public static void main(String[] args) {
Privte1 privte1=new Privte1("张三",18);//声明并实例化对象
privte1.toString(); //调用方法
System.out.println(privte1);
}
}
程序输出结果：
Privte{name='张三', age=18}
关于Setter方法，除了有初始化功能之外还可以修改内容，所以在类定义中必不可少的。
构造方法的重载
1.同一个类2.多个方法的方法名字相同
3.参数列表不同
参数个数不同
参数的数据类型不同
不同数据类型的参数顺序不同
方法的重载和修饰符无关
方法的重载和有无返回值无关
方法的重载和返回值类型无关
方法的重载和参数名无关
范例：构造方法的重载
class Person { //定义一个类
private String name; //[成员属性] 姓名
private int age; //[成员属性] 年龄
public Person(){ //定义无参构造方法
name="三"; //设置属性
age=1;
}
public Person(String name) {//定义单参构造方法
this.name = name;
}
public Person(String name, int age) {//定义双参构造方法
this.name = name; //初始化
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class JavaDEmo{
public static void main(String[] args) {
Person person=new Person("张三"); //声明并实例化对象
person.toString(); //进行方法调用
System.out.println(person);
}
}
程序输出结果：
Privte{name='张三', age=18}
编写顺序：在一个类中的构造方法重载时，所以的重载的方法按照参数的个数由多到少，或者是又少到多排列，即下列两种排列方式：
| 由少到多 | 由多到少 |
|---|---|
| public Person(){} | public Person(String a,int b){} |
| public Person(Sting a){} | public Person(Sting a){} |
| public Person(String a,int b){} | public Person(){} |
而且现在每个类中有成员属性、构造方法、普通方法，在三者定义的规范顺序：首先定义成员属性、其次定义构造方法、最后定义普通方法。
this关键字
This描述的是本类结构调用的关键字，在Java中this关键字可以描述3种结构的调用：
1、当前类中的属:this.属性。
2、类中的方法（普通方法、构造方法）：this()、this.方法名称（）；
3、描述当前对象
this调用本类属性
在一个类中，有同样名字的，需要this来描述成员属性
范例：通过this.成员属性访问
class Person { //定义一个类
private String name; //[成员属性] 姓名
private int age; //[成员属性] 年龄
public Person(){ //定义无参构造方法
name="三"; //设置属性
age=1;
}
public Person(String name) {//定义单参构造方法
this.name = name;
}
public Person(String name, int age) {//定义双参构造方法
this.name = name; //使用This标注本类属性
this.age = age; //使用This标注本类属性
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name; //使用This标注本类属性
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age; //使用This标注本类属性
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class JavaDEmo{
public static void main(String[] args) {
Person person=new Person("张三"); //声明并实例化对象
person.toString(); //进行方法调用
System.out.println(person);
}
}
程序输出结果：
Privte{name='张三', age=18}
在本构造方法中采用的参数名称和类成员属性名称完全相同，所以使用了this来设置。
this调用本类方法
1、this调用本类普通方法：可以使用this.方法()调用，并且可以在构造方法中使用。
2、调用本类构造方法：调用本类其他构造方法使用this()形式，此语句只允许放在构造方法首行使用
范例：使用this调用普通方法
class Person { //定义一个类
private String name; //成员属性：姓名
private int age; //成员属性：年龄
public Person(String name, int age) {
this.setName(name);
setAge(age);
}
public void tell(){
System.out.println("姓名："+this.name+"、年龄："+this.age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class putong {
public static void main(String[] args) {
Person person=new Person("张三",19);//实例化对象
person.tell(); //调用方法
}
}
程序输出结构：
姓名：张三、年龄：19
原因：
调用了类的普通方法，因为实在本类中，所以对this没有明确要求。
范例：使用this()实现本类构造方法互相调用
class Person { //定义一个类
private String name; //成员属性：姓名
private int age; //成员属性：年龄
public Person(){
System.out.println("对象实例化");
}
public Person(String name){
this();
this.name = name;
}
public Person(String name, int age) {
this(name);
this.age = age;
}
public void tell(){
System.out.println("姓名："+this.name+"、年龄："+this.age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class putong {
public static void main(String[] args) {
Person person=new Person("张三",19);//实例化对象
person.tell(); //调用方法
}
}
程序输出结构：
姓名：张三、年龄：19
综合案例
范例：描述一个部门的简单Java类
public class Dept { //定义一个类
private String name; //成员属性
private int id;
private String dizhi;
public Dept(){ //无参构造方法
}
public Dept(String name, int id, String dizhi) {
this.name = name;
this.id = id;
this.dizhi = dizhi;
}
public String getName() { //
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getDizhi() {
return dizhi;
}
public void setDizhi(String dizhi) {
this.dizhi = dizhi;
}
public void toll(){ //获取对象
System.out.println("部门名称："+this.name+"\t部门:"+this.id+"\t地址:"+this.dizhi);
}
}
public class TestDept {
public static void main(String[] args) {
Dept dept = new Dept("Java",1234,"中国");
dept.toll();
}
}
程序输出结果：
部门名称：Java 部门：1234 地址：中国
代码块
普通代码块
利用这类代码块可以解决在方法中导致重复变量定义的问题。
2、构造代码块
范例：定义构造代码块
class putong1 {
public putong1(){
System.out.println("构造方法");//构造方法
}
{ //构造代码块
System.out.println("代码块执行");
}
}
public class putong{
public static void main(String[] args) {
new putong1(); //实例化对象
}
}
程序执行输出：
代码块执行
构造方法
静态代码块
1、如果在一个构造代码块上使用static关键字，那就用静态代码块表示：1、在非主类中定义代码块。2、在主类中定义静态代码块。
范例：在非主类定义静态代码块
class putong1 {
public putong1(){
System.out.println("构造方法");//构造方法
}
static { //静态代码块
System.out.println("代码块执行");
}
}
public class putong{
public static void main(String[] args) {
new putong1(); //实例化对象
}
}
程序执行输出：
代码块执行
构造方法
注意：静态代码只执行一次
范例：在主方法定义静态代码块
public class putong {
static {
System.out.println("构造方法");//构造方法
}
public static void main(String[] args) { //主方法
System.out.println("主方法");
}
}
程序执行输出：
构造方法
主方法
注意：
主类定义的静态代码块要优先于主方法。
总结
1、面向对象的三大特征：封装、继承、多态性。
2、类与对象的关系：类是对象的模板，对象是类的实例、类只能通过对象才可以使用。
3、类的组成：成员属性、方法。
4、对象的实例化格式：类名称 对象名称 = new 类名称(),关键字new 用于内存空间开辟。
5、如果一个对象没有实例使用，会出现空指向异常。
6、构造方法与类名称相同、无返回值类型。
7、在Java中使用this关键字可以表示当前对象，通过this.属性调用本类中的属性，通过**this.方法()在本类调用其他方法，也可以通过this()**调用本类的构造方法，要求放在构造方法的第一行。
扫一扫
1524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
