Java-面向对象编程

面向对象

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

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

三大特征

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

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

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

三大思想

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

  • OOA:面向对象分析(Object Oriented Analysis)

  • OOD:面向对象设计(Object Oriented Design)

  • OOP:面向对象程序(Object Oriented Programming )

举例:

Scanner   sc = new  Scanner(System.in);

分析:

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

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

3Scanner(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语言实现的,更多的是CC++以文件的形式来实
          现的);
方法的调用

方法的分类(从静态与非静态的角度分): 静态方法 和 非静态方法;

静态方法:    【类名.方法名称】进行调用;

实例方法:    创建对象,   再【对象.方法名称】进行调用;

方法的分类(有无返回值的角度分):有返回值 和 无返回值;

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

无返回值 :    调用方法();

方法的分类(有无参数列表角度分):有参数 和 无参数;

有参数的方法:    调用方法(实际值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;
	}

}

你可能感兴趣的:(面试题,java,jvm,开发语言)