Java-面向对象编程

面向对象

面向对象是Java核心的内容部分，在学习的过程中首先需要掌握各种知识点，利用知识点进行程序的设计。面向对象的运用是一个漫长的过程，关系到程序设计的各个方面，不仅仅是编写代码部分。

面向对象的相关内容是比较抽象的，掌握的难度上会有所增加。

三大特征

• 封装：核心思想就是**“隐藏细节”、“数据安全”**，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。所有的内容对外部不可见。

• 继承：子类可以继承父类的属性和方法，并对其进行拓展。将其他的功能继承下来继续发展 。

• 多态：同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。方法的重载本身就是一个多态性的体现。

三大思想

面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP

• OOA：面向对象分析（Object Oriented Analysis）

• OOD：面向对象设计（Object Oriented Design）

• OOP：面向对象程序（Object Oriented Programming ）

举例：

Scanner   sc = new  Scanner(System.in);

分析：

1、Scanner 就是Java中的一个class类。

2、new 关键字的含义。 ----new其实就是在堆内存中开辟空间创建对象。

3、Scanner(System.in); ---- 是啥？

   答：调用Scanner类的构造，创建出sc这个对象。System.in仅仅是提供的一个参数而已！
   
4、通过调用sc对象中的各种方法来扫描控制台不同类型的数据。   

---

类的定义

类的定义

在Java语言中，class类是最为基本的单元。

类：其实就是针对某一类事物的抽象描述，是一个模板。

类的设计语法、

类的修饰符	使用的对象
public(公开的)	类，接口，变量，方法（使用最广）
private（私有的）	变量，方法，注意：不能修饰类（外部类）
default （默认的）	类，接口，变量，方法
protected（受保护的）	变量，方法，注意：不能修饰类（外部类）

类的修饰符   class   类名{
       
}   

说明：

1、类的修饰符：public（缺省） 、abstract 、 final

2、class：是定义类的关键字；

3、类名：符合标识符的定义规范（首字母大写，多个单词合并则每个单词的首字母大写【参考源码】）；

4、{ } ： 类的主体部分，称为“类体”；

从以上的语法分析中，我们可以看出，设计一个类的外壳的时候，我们只需要关注各种修饰符即可。

public 、 缺省（不写） ： 属于权限修饰符；

public  class   MyClass{
    
}

说明：MyClass这个类可以在一个Java项目中的任意的位置进行使用；


class   MyClass{
    
}

说明：MyClass这个类只能是在同一个包package下可以进行使用；

在项目开发中，可以适当的借助于不同的权限修饰符，来针对我们的类进行隔离。

abstract 、 final ：属于具有特殊含义的修饰符；

abstract : 修饰一个类的时候，表示这个类是一个“抽象类”。

final ：修饰一个类的时候，表示这个类是不允许被继承的(不允许作为父类)。

源码中的String类就是这样设计的:     源码  public final class String

注意！

abstract 和 final 是不能同时搭配使用的；

在Java语言中，有一个永恒成立的等式：

java类 = 属性  +  方法

换言之： 类 是由属性 和 方法所构成的 ，属性和方法都是定义在类的类体之中 。

类中的属性

属性：其实指的就是类中的成员变量（全局变量），是针对事物外部特征的描述；

全局变量分为2类：
              
    a-----静态变量；
                  	
    b-----实例变量；

属性的定义语法

修饰符   [static]   数据类型  属性名称  [= 值];

属性的修饰符有哪些？

public ：公共的；

缺省 ： 同一个包下可以进行访问;

protected : 具有2层含义：
     
         a、同一个包下可以进行访问；
         
         b、具有继承关系的可以进行访问（不关系包的位置）；

private ：只能在本类中进行使用，跨类则不能访问；

----------------------------------------------------------

static ： 修饰属性表示这是一个静态的变量；

final ： 表示一个常量，必须要手动赋值；

transient ： 修饰属性防止属性被序列化（后续讲解）；

volatile ： 属性同步的约定（涉及到Java多线程）；

属性的访问

属性就是对象的外部特征的描述，我们在使用的过程中：

如果是静态的属性： 【类名.属性】名称 进行访问；

如果是实例的属性： 创建对象 ， 再通过【对象.属性】进行访问；

类中的方法

方法：也称为“函数”，就是针对事物的功能进行的描述（表示能够干什么事情）。

     方法从静态性与否的角度进行分类：
        
           a、静态方法
           
           b、实例方法

方法的定义语法

修饰符   [static]   void|数据类型   方法名称(参数列表.....){
    //方法体;
    [return 值;]
}

方法的修饰符有哪些？

public ：公共的；

缺省 ： 同一个包下可以进行访问;

protected : 具有2层含义：
     
         a、同一个包下可以进行访问；
         
         b、具有继承关系的可以进行访问（不关系包的位置）；

private ：只能在本类中进行使用，跨类则不能访问；

-------------------------------------------------------------

static : 修饰的方法为静态方法；

final ：修饰的方法为最终版本的方法，这种方法是不能被重写的；

synchronized ： 修饰的方法为线程同步（后续讲解）；

abstract ： 抽象方法（抽象类的时候进行讲解）；

native ： 本地方法（这种方法是没有方法体的，内部使用的是非Java语言实现的，更多的是C和C++以文件的形式来实
          现的）；

方法的调用

方法的分类（从静态与非静态的角度分）： 静态方法 和 非静态方法；

静态方法：    【类名.方法名称】进行调用；

实例方法：    创建对象，   再【对象.方法名称】进行调用；

方法的分类（有无返回值的角度分）：有返回值 和 无返回值；

有返回值 ：    数据类型  变量  =  调用方法()；

无返回值 ：    调用方法()；

方法的分类（有无参数列表角度分）：有参数 和 无参数；

有参数的方法：    调用方法(实际值1，实际值2，....);

无参数的方法：    调用方法();

区分静态和非静态

加载时机不同

• 静态
  • 一个类中的静态成员会在类加载的时候，首先进行初始化（创建并产生默认值）；
• 非静态
  • 一个类中的实例成员会在创建类的对象的时候，才进行初始化；

生命周期不同

• 静态
  • 静态的成员在类加载的时候创建，类被删除的时候销毁，声明周期较长；
• 非静态
  • 实例成员在创建对象的时候初始化，对象销毁的时候一起销毁，相对较短；

共享性不同

• 静态
  • 静态的成员是被这个类的对所有的对象共享的；
• 非静态
  • 实例的成员是被每个对象独立的拥有；

访问方式不同

• 静态
  • 静态的就是通过【类名.进行访问】；
• 非静态
  • 实例成员必须要创建对象，再通过【对象.进行访问】;

过渡！

我们为何要使用Java作者开发出来的那些类？

   答：因为这些类中包含了我们所需要的一些功能，我们可以不用编写Java程序代码而直接使用。
   
Java内部提供的所有的类，是不能完全满足我们的现实需求的，所以我们就需要自己定义出新的类。那么定义新的类的目
标是什么呢？

   答：如何使用这个类？需要创建类的对象来进行使用内部的属性和方法。
   

结论：定义类不是目的，最终是为了使用类中的属性  和 方法。

对象的定义

对象的定义

class类是具有抽象性的，是对某一类事物的描述，它是一个基础也是一个前提条件，也可以把它视为一个“模板”。

我们基于这个“模板”所产生出来的一个一个具体的东西，就称为“对象”。

对象是客观存在的一个一个的个体，是看得见摸得着的客观事物。

类：是抽象描述每一类事物------模板；

对象：是类的具体化，客观存在的实体-----具体化；

类的具体化

针对已经存在的某个类，如何将其进行具体化呢？也就是如何创建出具体的对象呢？

我们使用的是类中的【构造方法】来实现的；

class类-------【构造方法】--------对象

什么是构造方法

构造方法也是属于方法，就是在类中使用类的名称作为方法的名称，并且永远都是如此。而且是没有所谓的返回值的约定（连void都没有），因为构造方法不做别的事情，就是生成对象的。

public  class  Student{
    
    //构造方法
    public  Student(){ 
    }
    
   
}

构造方法的特点

构造方法是特殊的方法，存在如下的几个特点：

1、构造方法的名称永远和类的名称是一致的；

2、构造方法永远是没有返回值的约定的，连void都没有；

3、一个类中可以同时存在多个构造方法，参数上会存在差别，不同的构造表达了不同的初始化程度；

public class Student {
	
	//属性
	public  String name;
	
	public  int   age;
	
	public  char  sex;
	
	//无参数的构造方法
	public  Student(){
		
	}
	//带有1个参数的构造方法
	public  Student(String name){
		//打印的name是局部变量中的name的值
		//局部变量和全局变量重名的时候，遵循的是就近原则
		//System.out.println(name); // “刘德华”  而不是 null
		this.name=name;
		//当成员变量和局部变量重名的时候，我们使用的是this关键字来进行区分的
		//this代表的是当前类（Student）的对象
	}
	//带有3个参数的构造方法
	public  Student(String name,int  age,char sex){
		this.name=name;
		this.age = age;
		this.sex = sex;
	}		
}


Test.java

public class Test {
	
	public static void main(String[] args) {
		/*
		//创建1个学生对象
		Student  stu1 = new  Student();
		//属性都是默认值
		System.out.println(stu1.name);//null
		System.out.println(stu1.age);//0
		System.out.println(stu1.sex);//空白字符
		
		*/
		
		/*
		Student   stu2 = new  Student("刘德华");
		*/
		
		//使用同一个构造，创建多个对象
		Student   stu3 = new  Student("张学友",30,'男');
		System.out.println(stu3.name);
		System.out.println(stu3.age);
		System.out.println(stu3.sex);
		
		Student   stu4 = new  Student("张三丰",40,'男');
		System.out.println(stu4.name);
		System.out.println(stu4.age);
		System.out.println(stu4.sex);		
	}
}

说明！

1、调用构造创建对象的时候，使用的是new关键字；

2、选择使用不同的构造方法来创建对象，表达的是对当前这个对象不同程度的初始化；

4、我们调用构造方法的时候，使用的是 new 关键字；

5、当我们的一个类中没有手动定义构造的时候，系统会默认一个不带参数的构造，一旦出现手动定义的构造，系统就不再
   默认了。
   
6、一个类中同时存在的多个构造方法，就是构成了最为典型的“方法的重载”；   

方法的重载

• 方法名相同；
• 方法的参数不同（参数类型不同，参数的个数不同，参数的顺序不同）：满足这三个条件至少一条即可认为参数的方法参数不同，

/**
 * MyBean类中定义几个方法来实现某些功能
 * 
 * 演示方法的重载(MyBean类中的4个方法就构成了方法的重载)
 */
public class MyBean{
    public double area(double a,double b){
        double c = a*b/2;
        System.out.println("三角形的面积"+c);
        return c;
    }
    public static void area(int a,int b){
        System.out.println("长方形的面积"+a*b);
    }
    public static double area(int r,double pi){
        double b = pi*r*r;
        System.out.println("圆的面积"+b);
        return b;
    }
    public static void area(int a,int b,int c){
        System.out.println("梯形的面积"+(a+b)*c/2);
    }
}


public  class  DemoMathMain {
    public static void main(String[] args) {
        Student.area(16,18);
        double d = Math.PI;
        Student.area(9,d);
        Student.area(16,15,4);
        Student student = new Student();
        student.area(1.2,3.4);
    }
}

注意：
声明为final的方法不能被重载，

声明为static的方法不能被重载，但能够再次声明

方法重载的优势

在功能确定的情况下，最大化满足外界灵活多变的需求。  比如：Arrays.sort(各种类型的数组);

附加内容：可变参数的使用

//任意的多个整数之和，咋办？---使用数组定义
	/*
	 * public int getSum(int[]  is){
		int sum = 0 ;
		if(is!=null&&is.length>0){
			for(int value:is){
				sum+=value;
			}
		}
		return sum;
	}
	*/
	
	//使用可变参数来定义方法----可变参数
	public  int  getSum(int...  is){
		//在定义可变参数的时候，在参数列表中最多只能有1个，并且只能在列表的末端
		int sum = 0 ;
		if(is!=null&&is.length>0){
			for(int value:is){
				sum+=value;
			}
		}
		return sum;
	}
	

在方法进行调用的时候的差异对比：

        //首先需要将数据保存数组中
		int[]  is = {1,2,3,4,5,6};
		//才能使用这个方法来进行求和
		int sum = mb.getSum(is);	
		
		//使用可变参数后，的调用情况如下
		int sum = mb.getSum(1,2,3,4,5,6,7,8,9,10); //直接给出数据，不用在数组中进行封装,简单方	

构造方法的作用

1、基于类创建出对象；
2、基于创建的这个对象进行不同程度的初始化；

this关键字

this关键字永远表示的是 当前这个类的对象 的指代, 它是一个变量 ；

public class User {
	
	public  String  name;
	
	public  int   age;
	
	public   String  address;
	
	
	//自定义一个方法
	public  void   method1(){
		//通过user1.method1调用方法的时候，this指代的user1这个对象
		this.name = "admin";
		//通过user2.method1调用方法的时候，this指代的user2这个对象
		
		//总结：
		//不管是user1 还是 user2对象，都是属于User这个类的对象；
	}
    ...............
}	

UserTest.java

public class UserTest {

	public static void main(String[] args) {

		User user1 = new User();
		user1.method1();

		User user2 = new User();
		user2.method1();
	}
}

注意！

this关键字的使用场景：

1、用于在同一个类中进行重名的 局部变量 和 成员变量 的区分；

2、在同一个类中，this可以用于在【非静态的方法中】进行方法的互调；

​ 【this关键字是无法使用在静态的方法或者语句块中的】

3、在同一个类中，this可以进行构造的互调，并且只能是在第一行的位置；

类中的代码块

代码块：其实可以理解为一个没有名字的方法，也就是说属于“方法”的范畴。

在Java的类中，代码块可以分为2种形式：

• 静态代码块

  • 为类中的静态成员做提前的准备和初始化工作

• 实例代码块

  • 为类中的实例成员做提前的准备和初始化工作

package com.it.www.oop1;

public class User {
	
	//main方法是程序执行的入口----JVM来控制的
	//在main方法执行之前需要有哪些动作？-----  类的加载的过程
	public static void main(String[] args) {
		new  User();
	}
	
	//静态代码块-------1、自动执行的      2、何时被自动执行的? (执行的比较早)
	static{
		System.out.println("----static-----");
	}
	
	//实例代码块-------1、自动执行   2、在创建User类的对象的时候执行的
	{
		System.out.println("----instance----");
	}

}

提示！

不管是静态代码块还是实例代码块，都是属于方法。

完整的一个类的加载顺序

package com.it.www.oop1;

public class User {
	
	private   static    int  age = 30;
	
	private    String   name = "name";
	
	public  User(){
		System.out.println("----User----");
	}
	
	//main方法是程序执行的入口----JVM来控制的
	//在main方法执行之前需要有哪些动作？-----  类的加载的过程
	public static void main(String[] args) {
		new  User();
	}
	
	//静态代码块-------1、自动执行的      2、何时被自动执行的
	static{
		System.out.println("----static-----");
	}
	
	//实例代码块-------1、自动执行   2、在创建User类的对象的时候执行的
	{
		System.out.println("----instance----");
	}

}

总结：

1、在类被加载的过程中，所有的静态成员都被创建和初始化了。

2、在创建对象的过程中，才会针对所有的实例成员进行创建和初始化。

3、针对任意的成员变量，都会存在一个创建 （系统初始化值） + 初始化（手动赋值）。

继承关系

继承的基本概念

​ 继承是面向对象的三大特征之一，继承可以降低代码的冗余性，提高代码的效率，通过继承，子类获得父类的**成员变量，方法。**一个子类如何继承父类的字段和方法。

​ 继承：是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例和方法，或子类从父类继承方法种，使得子类具有父类相同行为。

​ **继承的作用：**通过继承可以快速的创建一个类，实现代码的重用，提高程序的可维护性，节省大量时间，创建新类的时间，提高开发效率和开发质量，

​ 在Java种通过extends关键字可以申明一个类是从另外一个类继承而来的，

继承定义语法

继承机制的实现，就是在类的后面使用extends关键字来进行定义：

public  class  Student   extends  Person{
     .......................
}

public  class  Teacher  extends  Person{

}

Student类：是子类；

Person类：是父类（基类）；

注意！

在Java语言中【类与类之间】的继承，只能支持【单继承】。

继承案例

Person.java

package com.it.www.oop2;
/**
 * 父类(基类)----继承了Object类
 */
public class Person {
	
	public  String  name;
	
	public  int   age;
	
	public  char  sex;
	
	public   void   sleep(){
		System.out.println("人睡觉!");
	}
	
	public   void   eat(){
		System.out.println("人吃饭!");
	}
}

Student.java

package com.it.www.oop2;
/**
 * 子类-----继承的是Person类
 */
public class Student extends  Person{
	
    //通过继承来进行了替代
    /*public  String  name;
	
	public  int   age;
	
	public  char  sex;
	
	public   void   sleep(){
		System.out.println("人睡觉!");
	}
	
	public   void   eat(){
		System.out.println("人吃饭!");
	}*/
	
	//以下的属于学生特有的属性 和 方法
	public  int  sNo;//学号
	
	public  void  study(){
		System.out.println("学生学习!");
	}
}

Student_Test.java

package test;

import com.it.www.oop2.Student;

public class Student_Test {
	
	public static void main(String[] args) {
		//创建一个学生对象
		Student  student = new  Student();
		
		//使用的是父类Person中继承过来的属性和方法
		student.name="小花";
		student.sex='女';
		student.age = 25;
		
		student.eat();
		student.sleep();
		
		//使用的是Student自身特有的属性和方法
		student.sNo = 1001;
		student.study();
				
	}
}

备注！

在继承的过程中，并不是将父类中所有的属性和方法都能同时继承过来，取决于各种不同的修饰符的规则。

在继承的使用中，可以适当的使用不同的修饰符针对属性和方法进行保留。

在使用继承的过程中，需要注意的事项：

1、extends的实现，一定是依赖父子之间的构造方法的。

2、子类的构造中通过super来调用了父类中相应的构造方法来进行初始化（不能不对应，否则继承不成立）。

3、super就是用于在子类的构造中调用父类的构造，只能在是子类的构造方法的第一行，所以和this实现构造互调的时
   候，不能搭配使用。

super关键字

super关键字的使用场景

1、用于父子之间的构造方法中，实现构造的调用。

2、在父子类之间可以通过super来区分重名的属性 和 方法。

3、语法特点：super只能是使用在非静态的方法或者语句块中。

4、super关键字必须要写

方法的重写

方法重写的定义

• 继承关系中（方法名相同，参数列表相同，返回数据类型）称为“方法的重写”

• 方法的重写也讲为：“方法的覆写”、“方法的改写”。

方法重写案例

Demo.java（父类）

public class Demo {
    int age ;
    String name ;
    String sex;

    void  test(){
        System.out.println("张三");
        System.out.println("18");
        System.out.println("nan");
    }
}

DemoSon.java（子类）

public class DemeSon extends Demo{

    void  test(){
        super.age=89;
        super.name = "张三";
        super.sex="男";
        super.test();
    }

}

Demo1.java(测试类)

public class Demo1{
    public static void main(String[] args) {

        DemoSon1 demeSon = new DemoSon1();
        demeSon.test();

    }

}

附加知识点！

User.java

package com.it.www.bean;

public class User {
	
	
	public  String name;
	
	public   int  age;

	public User() {
		super();
	}

	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	//重写了Object类中的toString方法
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}

}

UserTest.java

package test;

import com.it.www.bean.User;

public class UserTest {
	
	public static void main(String[] args) {
		
		User user = new User("admin",30);
		
		//打印输出(地址)----默认的调用的是toString方法
		System.out.println(user); //com.it.www.bean.User@15db9742
		//重写toString方法后的结果:User [name=admin, age=30]				
	}	
}

需求：

User 对象 user1===== [name=“admin”,age=30]

User对象 user2===== [name=“admin”,age=30]

user1 和 user2 是两个不同的对象，但是数据信息又是相同的。我们想比较出2个对象中的数据是否相同？

答：重写类中的equals方法，实现的是内容信息的比较即可。

//重写父类的equals方法-----实现内容信息的比较
public boolean equals(Object obj) {
		
		if(this==obj){
			return true;
		}
		
		if(obj instanceof User){
			
			User user = (User)obj;
		//this.name中的equals方法，就是String类中的equals方法，作者已经重写过了，实现的内容的比较
			if(this.name.equals(user.name)&&this.age==user.age){
				return true;
			}
		}
		return false;
	}

注意！

Object 类中的equals方法实现的是对象的地址的比较。

String类中的equals方法已经重写过了，实现的是内容信息的比较。

将来自定义的类中的equals方法比较的是什么？取决于自己是否进行重写。

重写和重载的区别

重写是发生在继承关系中的，
      方法名相同，参数列表相同，返回数据类型形同


同一个类中，
     方法名相同
      参数不同（数量不同，顺序不同，数据类型不同）

总结

• 父类中的属性定义为私有，子类不能继承其父类中的private成员，如果我们子类想要访问父类成员可以写为public和不写，protected，
• 子类继承父类之后，其成员修饰符必须大于或者等于父类中的修饰符，不可将其降低修饰符的访问权限，
• 方法的重写一定是在父子类继承关系中产生的
• 子类无法访问父类中的静态（static）成员
• 子类重写父类中的方法，（方法名必须和父类中的相同，方法中的参数一致，返回的数据类型一致）
• super关键字：可以在子类中通过super来调用父类中的被重写的方法和访问父类中成员；

多态

概念

​ 多态是面向对象中最重要的特征之一，指同一个事物在不同场景下有着不同的形式。同一个对象在不同时刻，代表的对象不一样，指的是对象的多种形态。

​ 可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

特点

• 多态的前提是：
  • 继承
  • 要有方法的重写
• 父类引用指向子类对象：Demo demo = new DemoSon();
• 多态中，编译看左边，运行看右边。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RoeLvEPj-1677669224022)(面向对象.assets/image-20220808150342073.png)]

多态案例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zKUoyW0A-1677669224024)(面向对象.assets/image-20221026101303918.png)]

父类

/**
 * 多态的前提是：继承+重写
 * 创建父类
 */
public class Demo {
    public void eat(){
        System.out.println("水");
    }
}

子类1

/**
 * 创建子类
 */
public class DemoExtendsSon1 extends Demo{
    //重写父类中的eat方法
    public void eat() {
        System.out.println("0°一下----");
    }
    //延展子类中的方法
    public void jump(){
        System.out.println("冰");
    }
}

子类2

public class DemoExtendsSon2 extends Demo{
    //添加父类中的方法，进行重写
    public void eat() {
        System.out.println("0°以上------");
    }
    //延展子类方法，
    public  void run(){
        System.out.println("水");
    }
}

子类3

public class DemoExtendsSon3 extends Demo{
    //重写父类中的方法
    public void eat() {
        System.out.println("100°以上--------");
    }
    //子类方法延展
    public void du(){
        System.out.println("气");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jhjHTXTO-1677669224024)(面向对象.assets/image-20220808152501438.png)]

getter，setter方法

package com.sin.demoExtends;

public class DemoCar {
    //汽车品牌
    private String name;
    private    String color="五彩斑斓的黑";//汽车颜色
    private double money;//价格
    private int id;//汽车id

    public void start(){
        System.out.println("父类--这个车可以开"+color);
    }
    public void stop(){
        System.out.println("父类--这个车可以停");
    }

    public String getName(){//获取汽车名称
        System.out.println(name);
        return name;//返回汽车名称
    }
    public void setName(String name){//设置汽车名称
        this.name = name;//将参数name赋值给属性
    }

    public String getColor(){//获取汽车颜色
        System.out.println(color);
        return color;
    }
    public void setColor(String color){//
        this.color=color;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }


}

子类1

package com.sin.demoExtends;

public class DemoCarExtendsSon1 extends DemoCar{




    //重写父类方法
    public void start() {

        System.out.println("这个开的很快");
    }

}

子类2

package com.sin.demoExtends;

public class DemoCarExtendsSon2 extends  DemoCar{

    //重写父类方法
    public void stop() {
        System.out.println("这个车刹车灵");
    }
    //延展子类方法
    public void swim(){
        System.out.println("他的安全性高，有安全带");
    }
}

测试

public class TestDemoCar {
    public static void main(String[] args) {

        //实例化子类
        DemoCarExtendsSon1 demoCarExtendsSon1 = new DemoCarExtendsSon1();
        demoCarExtendsSon1.setName("劳斯莱斯");
        demoCarExtendsSon1.getName();

        demoCarExtendsSon1.setColor("黑色");
        demoCarExtendsSon1.getColor();

        demoCarExtendsSon1.setId(12138);
        System.out.println(demoCarExtendsSon1.getId());

        demoCarExtendsSon1.setMoney(10000000.23);
        System.out.println(demoCarExtendsSon1.getMoney());

        demoCarExtendsSon1.start();

        DemoCarExtendsSon2 demoCarExtendsSon2 = new DemoCarExtendsSon2();
        demoCarExtendsSon2.stop();
        demoCarExtendsSon2.swim();

    }
}

多态的好处

1，多态可以让我们不同关心某个对象到底具体是什么类型，就可以使用该对象的某些方法

2，提高了程序的可扩展性，可维护性

多态的使用

前提：多态的对象是将自己看作父类类型

• 成员变量：使用的是父类的
• 成员的方法：由于存在重写现象，所以使用的是子类的
• 静态的成员：随着子类调用父类加载而加载

抽象类

抽象类的基本概述

​ 普通类是一个完善的功能类，可以直接产生实例对象，并且普通类中有构造方法，普通方法，static方法，变量和常量等，而抽象类是指在普通类的结构里面增加了抽象方法的组成部分

​ 抽象类是无法实例化的，

​ 什么叫抽象方法：在所有的普通方法上面都会有“{}”，这表示方法体，有方法体的方法一定可以被对象直接调用，而抽象方法，是指没有方法体的方法 ，同时抽象方法还必须使用关键字abstract关键字来申明；

​ 拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明；

抽象类的使用

抽象方法的语法格式:

修饰符   abstract   void/数据类型   方法名称(参数列表...);

抽象的方法（父类）

/**
 * 抽象类
 * 1,可以写普通方法，
 * 2，可以写抽象方法
 * 3,可以写变量
 * 4,可以写常量
 * 5,不可以写静态抽象方法，
 * 6,可以写构造方法
 *7,可以写静态方法
 */
public abstract class DemoAbstatis01 {


    public void test(){
        System.out.println("helloword");
    }

    public abstract void test1();

    /**
     * 抽象方法，计算圆周长
     */
    public abstract  void getPerimeter();

    /**
     * 抽象方法，
     * 获取圆的面积
     */
    public abstract void getArea();

}

继承抽象方法的子类

public class DemoAbstractSon1 extends DemoAbstatis01{
    @Override
    public void test1() {
        System.out.println("我继承了我爸爸的抽象方法");
    }

     /**
     * 抽象的父类方法中强制实现的方法
     * 计算周长
     */
    @Override
    public void getPerimeter() {
        double r = 2.0;
        System.out.println("圆的周长"+Math.PI*2*r);
    }

    /**
     * 抽象的父类方法中强制实现的方法
     * 计算圆的面积
     */
    @Override
    public void getArea() {
        double r = 19.28;
        System.out.println("圆的面积"+Math.PI*r*r);
    }
}

测试类

public class DemoMain {
    public static void main(String[] args) {
        DemoAbstractSon1 demoAbstractSon1 = new DemoAbstractSon1();
        demoAbstractSon1.test1();
        demoAbstractSon1.test();
        demoAbstractSon1.getPerimeter();
        demoAbstractSon1.getArea();
    }
}

抽象类的使用原则：

• 抽象类的修饰符，必须为public/protected，也可以不用写，默认为public，不能写为private，
• 抽象类不能被直接实例化，可以通过子类采用向上转型的方式进行实例化，（使用父类实例化子类）
• 抽象类必须有子类，可以有多个子类继承，使用extends继承，一个子类只能继承一个父类。
• 子类在继承抽象父类的时候必须覆写抽象父类中的抽象方法，（如果不覆写父类中的抽象方法，则将类写为抽象类）
• 子类继承抽象父类的时候，抽象方法必须被覆写，普通方法可以选择性覆写。

向上转型

//抽象类---------------------------------------------------------------
/**
 * 自定义的抽象类
 */
public abstract class A {
    public void test(){//普通方法
        System.out.println("这是抽象类中的普通方法");
    }

    public abstract void test1();
}
//子类继承抽象父类---------------------------------------------------------------
/**
 * B类是抽象类的子类，是一个普通类
 */
public class B extends A{
    @Override
    public void test1() {
        System.out.println("helloword");
    }
}
//测试类---------------------------------------------------------------
public class DemoMain {
    public static void main(String[] args) {
        //向上转型（父类实例化子类）
        A c = new B();
        c.test();
        c.test1();
    }
}

• 抽象类也是一种复合引用类型。

• 类 可以继承 类

• 抽象类 可以继承 类

• 类 可以继承 抽象类

• 抽象类 可以继承 抽象类

练习

父类

public  abstract class DemoAbstract02 {
    /**
     * 长方形面积
     * @param a 长
     * @param b 宽
     * @return 长方形面积a*b
     */
    public abstract double area(double a,double b);

    /**
     * 三角形面积
     * @param a 底
     * @param b 高
     * @return 面积 a*b/2
     */
    public  abstract  double area(double a,int b);

    /**
     * 梯形面积
     * @param a 上底
     * @param b 下底
     * @param c 高
     * @return 体形面积 (a+b)*c/2
     */
    public abstract  double area (double a,double b , double c);

    /**
     * 三角形周长
     * @param a 边长
     * @param b 边长
     * @param c 边长
     * @return 三角形走场：a+b+c
     */
    public abstract double perimeter(double a,double b,double c);

    /**
     * 长方形周长
     * @param a 长
     * @param b 宽
     * @return （a+b）*2
     */
    public abstract double perimeter( double a, double b);

    /**
     * 正方形
     * @param a 边长
     * @return a*4
     */
    public abstract double perimeter( double a);

}

子类

public class DemoAbstractSon2 extends DemoAbstract02{
    /**
     * 长方形面积
     * @param a 长
     * @param b 宽
     * @return
     */
    @Override
    public double area(double a, double b) {
        double c=a*b;
        return c;
    }

    /**
     * 三角形面积
     * @param a 底
     * @param b 高
     * @return
     */
    @Override
    public double area(double a, int b) {
        double c= a*b/2;
        return c;
    }

    /**
     * 梯形面积
     * @param a 上底
     * @param b 下底
     * @param c 高
     * @return
     */
    @Override
    public double area(double a, double b, double c) {
        double e = (a+b)*c/2;
        return e;
    }

    /**
     * 三角形周长
     * @param a 边长
     * @param b 边长
     * @param c 边长
     * @return
     */
    @Override
    public double perimeter(double a, double b, double c) {
        double d = a+b+c;
        if (a==b && b==c){
            System.out.println("是等边三角形");
        }else if (a==b || a==c || c==b){
            System.out.println("这是等腰三角形");
        }
        return d;
    }

    /**
     * 长方形周长
     * @param a 长
     * @param b 宽
     * @return
     */
    @Override
    public double perimeter(double a, double b) {
        double c = (a+b)*2;
        return c;
    }

    /**
     * 正方形周长
     * @param a 边长
     * @return
     */
    @Override
    public double perimeter(double a) {
        double c = a*4;
        return c;
    }
}

测试类

public class DemoMain {
    public static void main(String[] args) {
        DemoAbstract02 demo = new DemoAbstractSon2();
        double c = demo.area(12.3,36.5);
        System.out.println("长方形面积"+c+"cm²");
        System.out.println("三角形面积"+demo.area(6.3,3)+"cm²");
        double a = demo.area(3.3,6.6,9.9);
        System.out.println("梯形面积"+a+"cm²");
        System.out.println("------------------------------------------------------------------");
        double a1 = demo.perimeter(9.9);
        System.out.println("正方形周长"+a1);
    }
}

接口

接口基本概念

​ 官方解释：Java接口就是以系列方法的声明，

​ 接口可以理解为特殊的类，里面全是全局变量，公开的抽象方法，所组成，接口解决的问题Java无法使用多继承的一种手段。一个接口只有方法的特征没有方法的具体实现。或者我们可以直接把接口理解为全部都为抽象类，接口中必须都为抽象方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p39Hmeuu-1677669224025)(面向对象.assets/image-20220810141526292.png)]

接口的特点

• 接口中全是抽象方法，全局变量，
• 接口指明了一个类必须要做什么，和不能做什么，

接口的定义语法

public|缺省   interface    接口名称{
    //定义常量： 
    //public  static  final  数据类型   常量名称 = 值;
    
    //抽象方法:
    //public  abstract  void/数据类型   方法名称(参数列表...);
}

注意！

接口是没有构造方法的，更不能创建对象。只是定义一种规则和规范。

package com.it.www.oop1;
/**
 * 介绍接口的语法格式
 * @author Administrator
 *
 */
public interface InterfaceA {
	
	public static final  String  NAME="admin";
	
	//在接口中定义常量的格式为：public static final
	//如果我们在定义的时候存在相应的省略，默认的也是 public static final
	public static   String  NAME1="admin";
	
	public    String  NAME2="admin";
	
	
	//所以我们通常在开发的过程中，为了相应的简化写法，一般是这样做的。
	String  NAME3="admin";
	
	
	//抽象方法:默认的修饰符是 public   abstract 
	public  abstract  void   method1(String name);
	
	//通常在开发中为了简化，可以这样写:
	void  method2(String name);	
}

接口使用

InterfaceB.java

package com.it.www.oop1;

public interface InterfaceB {
	
	//分页单位为 5
	int  PAGE_SIZE = 5;
	
	
	int   getPageSize();
	
	int   getPageData();

}

MyClass.java 实现类

package com.it.www.oop1;

/**
 * MyClass是一个类，这是实现InterfaceB这个接口的一个实现类。
 * @author Administrator
 */
public class MyClass implements InterfaceB {

	public int getPageSize() {
		//可以使用 this.PAGE_SIZE来进行使用，说明PAGE_SIZE已经是MyClass类中的常量了，所以，接口有这么一个规定
		//只要是这个接口的实现类，都可以毫无条件的共享接口中的全部常量。
		return this.PAGE_SIZE;
	}

	public int getPageData() {
		
		return 0;
	}

}

注意！

1、定义接口使用的是interface关键字；

2、接口中只有常量和抽象方法2部分；

3、实现类来实现接口使用的是implements关键字；

4、实现类一旦实现了某个接口，就可以毫无条件的共享接口中的所有常量；

InterfaceC.java

package com.it.www.oop1;

public interface InterfaceC {
	
	String  NAME = "刘德华";
	
	String   getName();
	
	int    getAge();

}

MyClass.java

package com.it.www.oop1;

/**
 * MyClass是一个类，这是实现InterfaceB这个接口的一个实现类。
 * @author Administrator
 */
public class MyClass implements InterfaceB , InterfaceC{

	public int getPageSize() {
		//可以使用 this.PAGE_SIZE来进行使用，说明PAGE_SIZE已经是MyClass类中的常量了，所以，接口有这么一个规定
		//只要是这个接口的实现类，都可以毫无条件的共享接口中的全部常量。
		return this.PAGE_SIZE;
	}

	public int getPageData() {
		
		return 100;
	}

	
	public String getName() {
		
		return this.NAME;
	}

	public int getAge() {
		return 30;
	}
}

提示！

同一个类可以同时实现多个接口，多个接口之间使用【，】号进行分隔；

InterfaceD.java

package com.it.www.oop1;
/**
 * 接口之间也是可以继承的，并且可以支持多重继承。
 * @author Administrator
 */
public interface InterfaceD  extends InterfaceB,InterfaceC {
	
	void   method01();
	
	void   method02();

}

MyClass1.java

package com.it.www.oop1;

/**
 * 实现类中需要实现的方法就包含了IntefaceB 、 C 、 D中的所有的抽象方法 和 共享了所有的接口中的所有常量
 * @author Administrator
 */
public class MyClass1 implements InterfaceD {

	public int getPageSize() {
		// TODO Auto-generated method stub
		return 0;
	}

	public int getPageData() {
		// TODO Auto-generated method stub
		return 0;
	}

	public String getName() {
		// TODO Auto-generated method stub
		return null;
	}

	public int getAge() {
		// TODO Auto-generated method stub
		return 0;
	}

	public void method01() {
		// TODO Auto-generated method stub

	}

	public void method02() {
		// TODO Auto-generated method stub

	}
}

提示！

1、接口之间是可以继承的，并且可以支持多重继承；

2、独立的接口就是某一类独立的操作，不同的接口可以同时作用（implements）在需要的类上；

3、弥补了Java中类只支持单继承的局限性；

上机任务

任务1：

编写一个接口：描述USB的功能。
      service 方法；
实现类1：U盘。
      连接接口，实现数据的传输
实现类2：USB电风扇。
      连接接口，接通电源，启动风扇

/**
 * usb的服务
 */
public interface USBService {

    public void useTxt();

}

/**
 * 实现类1，
 */
public class USBServiceImpl implements USBService{

    @Override
    public void useTxt() {
        System.out.println("连接接口，实现数据的传输");
    }
}

/**
 * 实现类2
 */
public class USBServiceImpl2 implements USBService {
    @Override
    public void useTxt() {
        System.out.println("连接接口，接通电源，启动风扇");
    }
}

/**
* 测试类
*/
public class TestMain {
    public static void main(String[] args) {
        USBServiceImpl service = new USBServiceImpl();
        service.useTxt();

        USBServiceImpl2 service1 = new USBServiceImpl2();
        service1.useTxt();
    }
}




方法2：-------------------------------------------------------------------
    /**
 * usb的服务
 */
public interface USBService {

    /**
     * 常量，功能1
     */
    public  final String U_DISK = "连接接口，实现数据的传输";

    /**
     * 常量，功能2
     */
    public final  String ELECTRIC_FAN="连接接口，接通电源，启动风扇";
    /**
     * 描述usb的功能
     */
    public void useTxt();

}
/**
 * 实现类1，
 */
public class USBServiceImpl implements USBService{


    @Override
    public void useTxt() {
        System.out.println(U_DISK);
    }

}
/**
 * 实现类2
 */
public class USBServiceImpl2 implements USBService {

    @Override
    public void useTxt() {
        System.out.println(ELECTRIC_FAN);
    }
}

任务2：

实现一个防盗门的功能：

门： 开门 、 关门的功能；

锁： 开锁 、关锁的功能；

防盗门  ---- 是门 ----- 锁

请问如何进行设计？

附加一个门铃（响，咔嚓拍照，进行存储）

如何进行设计？

接口的特点

1、定义的时候使用的是interface关键字；

2、接口就是用于负责定义功能（规范 或 标准）；

3、接口中是没有构造方法的；

4、接口都是通过实现类使用implements 来进行实现的；

5、接口中只有常量 和  抽象方法；

6、接口之间是可以进行继承的，并且可以支持多重继承；

7、接口重点在于一种设计中的使用（主要是针对模块 、 系统）之间来进行衔接的；

抽象类和接口的区别

抽象类与接口在语法上的区别

1.抽象类里可以有构造方法，而接口内不能有构造方法。
2.抽象类中可以有普通成员变量，而接口中不能有普通成员变量。
3.抽象类中可以包含非抽象的普通方法，而接口中所有的方法必须是抽象的，不
  能有非抽象的普通方法。
4.抽象类中的抽象方法的访问类型可以是public ，protected和默认类型，但接
  口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5.抽象类中可以包含静态方法，接口内不能包含静态方法。
6.抽象类和接口中都可以包含静态成员，抽象类中的静态成员变量的访问类
  型可以任意，但接口中定义的变量只能是public  static  final类型，并且默认为
  public  static  final类型。
7.一个类可以实现多个接口，但只能继承一个抽象类。
8.抽象类和接口所反映出的设计理念不同。其实abstract class表示的是“is-a”
  继承关系，interface表示的是“like-a”关系。

两者在应用上的区别

 接口更多的是在系统框架设计方法发挥作用，主要定义模块或者系统之间的通信，而抽象类主要在代码实现方面发挥作
 用，可以实现代码的重用。

面向接口编程模式

com.it.www.dao : 定义数据库操作的接口包；

com.it.www.daoi : 定义数据库操作的接口的实现包；

com.it.www.service : 定义项目业务操作的接口包；

com.it.www.servicei : 定义业务操作的实现包；

PersonDao.java 接口

package com.it.www.system;

public interface PersonDao {
	
	void  savePerson();
	
	void  queryPersons();

}

PersonDaoImple.java实现类

package com.it.www.system;

public class PersonDaoImple implements PersonDao {

	//实现的是接口中的方法
	public void savePerson() {
		System.out.println("---save Person----");

	}

	public void queryPersons() {
		System.out.println("----query  persons----");
	}
	
	//自己这个类的方法
	public  void   myMthod01(){
		System.out.println("----customer 1-----");
	}
	
	public  void   myMthod02(){
		System.out.println("----customer 2-----");
	}

}

Test.java

package com.it.www.system;

public class Test {
	
	public static void main(String[] args) {
		
		//使用 实现类的类型  创建  实现类的对象
		PersonDaoImple   personDaoImple = new  PersonDaoImple();
		
		personDaoImple.savePerson();
		personDaoImple.queryPersons();
		personDaoImple.myMthod01();
		personDaoImple.myMthod02();
		
		//使用面向接口编程模式
		
		//使用接口的类型  接收  实现类的对象
		PersonDao    personDao = new  PersonDaoImple();
		
		//是PersonDao的类型，就只能调用出PersonDao中定义过的方法。
		personDao.queryPersons();
		personDao.savePerson();
		
		//实现类PersonDaoImple中的自己的方法丢了。被接口给过滤了，所以，接口永远对外提供的功能都只是接口中定义过的功能。
	
		
		
	}

}

提示！

更多的基于接口的分层结构和面向接口的编程模式，见： day05_09 项目中；

封装

• 封装：（数据的隐藏）,通常，应该禁止直接方法一个对象中的数据，而是通过操作接口来访问，成为信息隐藏

public class User {
    //名字
    private String name;
    //性别
    private String sax;
    //年龄
    private int age;

    public User(){

    }

    public User(String name,String sax,int age){
        this.name = name;
        this.sax = sax;
        this.age = age;
    }

        public void test(String name, String sax, int age){

        this.name=name;
        System.out.println(name);
        this.sax = sax;
        System.out.println(sax);
        this.age = age;
        System.out.println(age);
    }


    public String getName() {//获取对象数据
        return name;
    }

    public void setName(String name) {//设置对象数据
        this.name = name;
    }

    public String getSax() {
        return sax;
    }

    public void setSax(String sax) {
        this.sax = sax;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.sin.pojo;

public class UserMain {
    public static void main(String[] args) {
        User user = new User();
        user.setName("张三");
        user.setAge(18);
        user.setSax("男");
        System.out.println(user.getName());
        System.out.println(user.getAge());
        System.out.println(user.getSax());

        User user1 = new User("李四","女",29);
        System.out.println();
        System.out.println(user1.getSax());
        System.out.println(user1.getName());
        System.out.println(user.getAge());
        
         user.test("王五","男",89);

    }
}

当一个类中的变量别private（私有）只能在当前类下访问，他无法在主程序中直接调用，需要其他的一些方法调用

怎么对类中私有的变量进行操作？

• get : 获取对象中的值
• set : 设置对象的值
• 构造方法，普通方法，

为什么封装

• 提高程序的安全性，保护数据
• 隐藏代码的实现细节
• 统一接口
• 提高系统的可维护性

内部类

内部类的基本知识

内部类：就是定义在一个类的内部的类。内部类就是专门负责独立的描述某一类事物，而这一类事物仅仅只是在当前这个所

在类的范围内进行使用。在类中的任意位置需要提供局部性的服务，就可以使用内部类来实现。

问题1：
   
   可以定义在一个指定的类内部的哪些位置？
   
   答：任意位置（直接在类体中、方法中、代码块中、语句块中）。
   
问题2：

   为什么要使用内部类?
    
   答：就是为了在一个类的内部的任意的位置提供局部性的服务。

内部类

• 成员内部类
• 局域内部类
• 匿名内部类
• 静态内部类

成员内部类

成员内部类，是最普通的内部类，它的定义为位于另一个类的内部，

public class Demo {
    public static void main(String[] args) {
        Demo demoA = new Demo();
        Demo.DemoA demoA1 = demoA.new DemoA();
    }
    public class  DemoA{
        public DemoA(){
            System.out.println("我是内部类");
        }
    }
}

局域内部类

局部内部类使用比较少,其声明在一个方法体中，在局部内部类里面可以访问外部类中的对象的所有访问权限的字段，而外部类不能访问局部内部类的中定义的字段。

public class Demo {

    private String name1 = "zhangsan";
    public static void main(String[] args) {
        Demo demo  = new Demo();
        demo.test1();
    }
    public void test1(){
        //局部类，-->基于普通方法之的class
        class A{
            private String name;
            public A(){//A类的无参构造方法
                System.out.println(name1);
                System.out.println("我是局部变量");
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
        }
        //创建对象的目的是：让Java虚拟机识别到A类的对象
        A a = new A();
        a.setName("王五");
        System.out.println(a.getName());
    }



}

匿名内部类

匿名内部类有很多种形式，其中最常见的一种形式为方法参数中新建一个接口对象/类对象，并且实现这个接口声明，类中原有的方法：

接口匿名内部类

public class Demo {

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.DemoTest();
    }

    //自定义接口
    public interface Test{
        //抽象方法
        public void test1();
        public String testName(String name);

    }

    private void DemoTest() {
        //在这个过程中会创建一个匿名内部类对象
        //这个匿名内部类实现Test接口中方法并重写test1
        Test test = new Test(){
            String name;

           @Override
           public void test1() {
               System.out.println("我是匿名内部类");
           }

           @Override
           public String testName(String name) {
               this.name=name;
               return name;
           }
        };
        //对象调取方法
      	test.test1();
        System.out.println(test.testName("我在测试匿名内部类"));
    }


}

抽象匿名内部类

public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.test1();
    }
    //自定义抽象类
    public abstract class Test{
        //抽象方法
        public abstract  String test(String name);

        public void test1(){
            System.out.println("这是匿名内部类中的普通方法");
        }
    }

    public void test1(){
        Test test = new Test(){
            String name;
            @Override
            public String test(String name) {
                this.name = name;
                return name;
            }
        };
        test.test1();
        System.out.println(test.test("这是抽象类的匿名内部类"));
        System.out.println("_______________");
    }
}

在方法中new一个接口/抽象类，并实现接口/抽象类中的抽象方法，在这过程中其实会创建一个匿名内部类实现这个接口/抽象类，并重写接口/抽象类中的方法。

静态内部类

一个类的静态成员独立于这个类的任何一个对象存在，只要在具有访问权限的地方，我们就直接可以类.方法名的形式来访问这个静态成员。静态内部类也可以作为外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖外部类对象，可以直接类名.方法名

public class Demo {
    public static void main(String[] args) {
        Demo1.test();
    }
    //自定义静态内部类
    static class Demo1{
        public Demo1(){
        }
        public static void test(){
            String name = "这是";
            String name1 = "静态";
            String name2 = "内部类";
            System.out.println(name+name1+name2);
        }
    }
}

上机任务：

以上我们使用针对User对象数组进行了自定义的排序处理，使用的是Comparetor接口，其实还存在另一个比较器的接口，同样可以实现在Arrays.sort中进行排序处理（自己查阅一下完成）。

标准JavaBean规范

JavaBean的定义：就是一个class类。

标准的JavaBean的定义：其实就是在JavaBean的基础上设置了一些规则和规范。

1、所有的属性都是private修饰的；

2、所有的属性的名称的首字母一定是小写的；

3、所有的属性都会对应一个公共的set（赋值） 和  get（取值）方法；

4、一般会添加上一个无参数的构造和一个全部带参数的构造；

注意！

以后我们会学习到Java的反射机制，反射机制中都会遵循标准JavaBean的规范来进行处理。

package com.it.www.entity;

public class User {
	
	private   String  name;
	
	private   String  address;
	
	private   int   age;
	
	private    char  sex;

	public User() {
		super();
	}

	public User(String name, String address, int age, char sex) {
		super();
		this.name = name;
		this.address = address;
		this.age = age;
		this.sex = sex;
	}

	//get方法是有返回值的，返回类型就是属性的类型，是没有参数的
	//get+属性名称的首字母大写+后面的所有的字符保持不变
	public String getName() {
		return name;
	}
	
	//属性：  Name
	//set方法名称：  setName
	//根据set方法名称还原属性名称
	//Name------name

	//set方法是赋值的，参数的类型就是属性的类型，是没有返回值的
	public void setName(String name) {
		this.name = name;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

}