方法的定义
方法的调用
静态方法
非静态方法
public class Demo02 {
public static void main(String[] args) {
Student student=new Student();
student.say();
}
//静态方法 static
/*1.新建一个Student类,并创建如下静态方法
public static void say(){
System.out.println("学生说话了");
}
2.在其他类中可以随意调用上面的静态方法,如果去掉static(即非静态),则不能调用
3.那么要如何才能调用非静态方法呢==》实例化这个类即可,如下(以Student为例)
Student student=new Student();
student.say();
*/
//非静态方法
/*实例化这个类
Student student=new Student();
student.say();
*/
}
形参和实参
public class Demo03 {
public static void main(String[] args) {
add(2,3);
}
public static int add(int a,int b){
return a+b;
}
}
/*
实参:2;3
形参:a;b
*/
值传递和引用传递
//引用传递:传递的是对象,实质还是值传递
public class Demo04 {
public static void main(String[] args) {
Person person=new Person();
System.out.println(person.name);//null
Demo04.change(person);
System.out.println(person.name);
}
public static void change(Person person){
person.name="qinjiang";
}
}
//定义一个Person类,有一个属性name
class Person{
String name;
}
this关键字
类是一种抽象的数据类型,它是某一类事物整体描述/定义,但是并不能代表某一个具体的事物
对象是抽象概念的具体实例
使用new关键字创建对象
使用new关键字创建对象的时候,除了分配内存空间之外,还会给创建好的对象进行默认初始化以及对类中构造器的调用
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的,并且构造器有以下两个特点:
构造器(有参构造器 无参构造器)必须要掌握
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示的定义构造器
String name ;//null
//实例化初始值
//无参构造
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person(){
this.name="qinjang1";
}
//有参构造 一旦定义了有参构造,无参构造就必须显示定义
public Person(String name){
this.name=name;
}
//alt+insert
}
/*
构造器
1.方法名和类名相同
2.没有返回值
作用
1.new:本质在调用构造方法
2.初始化对象的值
注意点:定义了有参构造之后,如果想调用无参构造,需要显示的(重新)定义一个无参的构造(构造一个空的构造器)
快捷键: Alt + Insert
this.*
*/
//一个项目应该只有一个main方法//总测试类
public class Application {
public static void main(String[] args) {
//使用new关键词实例化了一个对象person1
Person person1=new Person();
Person person2=new Person("qiangjang2");
System.out.println(person1.name);
System.out.println(person2.name);
}
}
/*
qinjang1
qiangjang2
*/
该露的露,该藏的藏
封装:(数据的隐藏)
实现封装的具体步骤如下:
以下是对个人信息的封装:
public class Person {
private String name; // 姓名
private int age; // 年龄
private String phone; // 联系电话
private String address; // 家庭住址
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//创建公用的取值赋值方法来对私有属性进行读写
public int getAge() {
return age;
}
public void setAge(int age) {
// 对年龄进行限制
if (age < 18 || age > 40) {
System.out.println("年龄必须在18到40之间!");
this.age = 20; // 默认年龄
} else {
this.age = age;
}
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
使用 private 关键字修饰属性,这就意味着除了Person类本身外,其他任何类都不可以访问这些属性。但是,可以通过这些属性的 setXxx() 方法来对其进行赋值,通过 getXxx() 方法来访问这些属性。
编写测试类PersonTest,在该类的 main() 方法中调用 Person属性的 setXxx() 方法对其相应的属性进行赋值,并调用 getXxx() 方法访问属性,代码如下:
public class PersonTest {
public static void main(String[] args) {
Person people1 = new Person();
people1.setName("王某");//给Person类的属性赋值
people1.setAge(35);
people1.setPhone("18730296717");
people1.setAddress("河北省保定市");
System.out.println("姓名:" + people1.getName());//调用Person类的属性
System.out.println("年龄:" + people1.getAge());
System.out.println("电话:" + people1.getPhone());
System.out.println("家庭住址:" + people1.getAddress());
}
}
练习:要求编写表示图书的 Book 类,实现以下需求:
基本信息包括图书名称(bookName)、总页数(bookTotalNum),其中页数不能少于 200 页,否则输出错误信息,并赋予默认值 200。
为各个属性设置赋值和取值方法。
具有 details() 方法,该方法在控制台输出每本图书的名称和总页数。
/*创建Book类,
1.添加bookName,并封装,getBookName/setBookname
2.添加bookTotalNum属性,并封装,getBookTotalNum/setBookTotalNum
3.在Book类中添加公有的details()方法,输出图书的名称和总页数
*/
public class Book {
// 书名
private String bookName;
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
// 图书总页数
private int bookTotalNum;
public int getBookTotalNum() {
return bookTotalNum;
}
public void setBookTotalNum(int bookTotalNum) {
if (bookTotalNum < 200) {
System.out.println(this.bookName + "这本书的页数不能少于 200 页");
this.bookTotalNum = 200;
} else {
this.bookTotalNum = bookTotalNum;
}
}
public void details() {
System.out.println(this.bookName + "这本书的总页数是:" + this.bookTotalNum);
}
}
public class BookTest {
public static void main(String[] args) {
Book book1 = new Book();
book1.setBookName("《简爱》");
book1.setBookTotalNum(100);
book1.details();
Book book2 = new Book();
book2.setBookName("《龙族》");
book2.setBookTotalNum(520);
book2.details();
}
}
/*
简爱总页数不能少于200页
书名:简爱 总页数200
书名:龙族 总页数520
*/
继承是面向对象的三大特征之一,继承与显示生活的"继承"的相识之处是保留一些父辈的特性,从而减少代码冗余,提高程序的运行效率
java中的继承就是在已经存在类的基础上进行扩展,从而产生新的类。已经存在的类称为父类、基类或超类,而新产生的类称为子类或派生类。在子类中,不仅包含父类的属性和方法,还可以增加新的属性和方法
extends的意思是说”扩展“。子类是父类的扩展
修饰符 class class_name extends extend_class {
// 类的主体
}
其中,class_name 表示子类(派生类)的名称;extend_class 表示父类(基类)的名称;extends 关键字直接跟在子类名之后,其后面是该类要继承的父类名称。例如:
public class Student extends Person{}
JAVA中类只有单继承,没有多继承(一个儿子只有一个爸爸,一个爸爸可能有多个儿子)
继承是类和类之间的一种关系,除此之外,类和类之间的关系还有依赖,组合,聚合等(子类继承父类所有的方法)
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
例一:
创建人类 People,并定义 name、age、sex、sn 属性,代码如下:
public class People {
public String name; // 姓名
public int age; // 年龄
public String sex; // 性别
public String sn; // 身份证号
public People(String name, int age, String sex, String sn) {
this.name = name;
this.age = age;
this.sex = sex;
this.sn = sn;
}
public String toString() {
return "姓名:" + name + "\n年龄:" + age + "\n性别:" + sex + "\n身份证号:" + sn;
}
}
创建 People 类的子类 Student 类,并定义 stuNo 和 department 属性,代码如下:
public class Student extends People {
private String stuNo; // 学号
private String department; // 所学专业
public Student(String name, int age, String sex, String sn, String stuno, String department) {
super(name, age, sex, sn); // 调用父类中的构造方法
this.stuNo = stuno;
this.department = department;
}
public String toString() {
return "姓名:" + name + "\n年龄:" + age + "\n性别:" + sex + "\n身份证号:" + sn + "\n学号:" + stuNo + "\n所学专业:" + department;
}
}
由于 Student 类继承自 People 类,因此,在 Student 类中同样具有 People 类的属性和方法,这里重写了父类中的 toString() 方法。
创建 People 类的另一个子类 Teacher,并定义 tYear 和 tDept 属性,代码如下:
public class Teacher extends People {
private int tYear; // 教龄
private String tDept; // 所教专业
public Teacher(String name, int age, String sex, String sn, int tYear, String tDept) {
super(name, age, sex, sn); // 调用父类中的构造方法
this.tYear = tYear;
this.tDept = tDept;
}
public String toString() {
return "姓名:" + name + "\n年龄:" + age + "\n性别:" + sex + "\n身份证号:" + sn + "\n教龄:" + tYear + "\n所教专业:" + tDept;
}
}
编写测试类 PeopleTest,在该类中创建 People 类的不同对象,分别调用它们的 toString() 方法,输出不同的信息。具体的代码如下:
public class PeopleTest {
public static void main(String[] args) {
// 创建Student类对象
People stuPeople = new Student("王丽丽", 23, "女", "410521198902145589", "00001", "计算机应用与技术");
System.out.println("----------------学生信息---------------------");
System.out.println(stuPeople);
// 创建Teacher类对象
People teaPeople = new Teacher("张文", 30, "男", "410521198203128847", 5, "计算机应用与技术");
System.out.println("----------------教师信息----------------------");
System.out.println(teaPeople);
}
}
/*
----------------学生信息---------------------
姓名:王丽丽
年龄:23
性别:女
身份证号:410521198902145589
学号:00001
所学专业:计算机应用与技术
----------------教师信息----------------------
姓名:张文
年龄:30
性别:男
身份证号:410521198203128847
教龄:5
所教专业:计算机应用与技术
*/
object类(ctrl+H 打开继承树)
由于子类不能继承父类的构造方法,因此,如果要调用父类的构造方法,可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。
super 关键字的功能:
super 关键字可以在子类的构造方法中显式地调用父类的构造方法,基本格式如下:
super(parameter-list);
其中,parameter-list 指定了父类构造方法中的所有参数。super( ) 必须是在子类构造方法的方法体的第一行。
声明父类 Person,类中定义两个构造方法。示例代码如下:
public class Person {
public Person(String name, int age) {
}
public Person(String name, int age, String sex) {
}
}
子类 Student 继承了 Person 类,使用 super 语句来定义 Student 类的构造方法。示例代码如下:
public class Student extends Person {
public Student(String name, int age, String birth) {
super(name, age); // 调用父类中含有2个参数的构造方法
}
public Student(String name, int age, String sex, String birth) {
super(name, age, sex); // 调用父类中含有3个参数的构造方法
}
}
public class Person {
int age=25;
public void infor(){
System.out.println("this is person class!");
}
}
public class Student extends Person {
int age=18;
void age1() {
System.out.println("学生年龄:" + super.age);
}
void age2() {
System.out.println("学生年龄:" + this.age);
}
void age3() {
super.infor();
}
}
public class Test {
public static void main(String[] args) {
Student stu = new Student();
stu.age1();
stu.age2();
stu.age3();
}
}
/*
学生年龄:25
学生年龄:18
this is person class!
*/
this 指的是当前对象的引用,super 是当前对象的父对象的引用。下面先简单介绍一下 super 和 this 关键字的用法。
super 关键字的用法:
如果构造方法的第一行代码不是 this() 和 super(),则系统会默认添加 super()。
this 关键字的用法:
java允许同一个类中定义多个同名方法,只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法,但形参列表不同,这种情况被称为方法重载(overload)
//在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。
public void println(int i){…}
public void println(double d){…}
public void println(String s){…}
法重载的要求是两同一不同:同一个类中方法名相同,参数列表不同。至于方法的其他部分,如方法返回值类型、修饰符等,与方法重载没有任何关系。
定义在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法,只是方法体中的实现不同,以实现不同于父类的功能,这种方式被称为方法重写(override),又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候,需要方法重写。
子类可以根据需要,定义特定于自己的行为。既沿袭了父类的功能名称,又根据子类的需要重新实现父类方法,从而进行扩展增强
在重写方法时,需要遵循下面的规则:
注意:
例
每种动物都有名字和年龄属性,但是喜欢吃的食物是不同的,比如狗喜欢吃骨头、猫喜欢吃鱼等,因此每种动物的介绍方式是不一样的。
下面编写 Java 程序,在父类 Animal 中定义 getInfo() 方法,并在子类 Cat 中重写该方法, 实现猫的介绍方式。父类 Animal 的代码如下:
public class Animal {
public String name; // 名字
public int age; // 年龄
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getInfo() {
return "我叫" + name + ",今年" + age + "岁了。";
}
}
子类 Cat 的代码如下:
public class Cat extends Animal {
private String hobby;
public Cat(String name, int age, String hobby) {
super(name, age);
this.hobby = hobby;
}
public String getInfo() {
return "喵!大家好!我叫" + this.name + ",我今年" + this.age + "岁了,我爱吃" + hobby + "。";
}
public static void main(String[] args) {
Animal animal = new Cat("小白", 2, "鱼");
System.out.println(animal.getInfo());
}
}
/*
喵!大家好!我叫小白,我今年2岁了,我爱吃鱼。
*/
在 Animal 类中定义了一个返回值类型为 String、名称为 getInfo() 的方法,而 Cat 类继承自该类,因此 Cat 类同样含有与 Animal 类中相同的 getInfo() 方法。但是我们在 Cat 类中又重新定义了一个 getInfo() 方法,即重写了父类中的 getInfo() 方法。
定义:多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。
对面向对象来说,多态分为编译时多态和运行时多态。其中编译时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来 区分不同的方法。通过编译之后会变成两个不同的方法,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是大家通常所说的多态性。
java实现多态有 3 个必要条件:继承、重写和向上转型。只有满足这 3 个条件,开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而执行不同的行为。
通过一个例子来演示重写如何实现多态性。例子使用了类的继承和运行时多态机制,具体步骤如下。
1)创建 Figure 类,在该类中首先定义存储二维对象的尺寸,然后定义有两个参数的构造方法,最后添加 area() 方法,该方法计算对象的面积。代码如下:
public class Figure {
double dim1;
double dim2;
Figure(double d1, double d2) {
// 有参的构造方法
this.dim1 = d1;
this.dim2 = d2;
}
double area() {
// 用于计算对象的面积
System.out.println("父类中计算对象面积的方法,没有实际意义,需要在子类中重写。");
return 0;
}
}
创建继承自 Figure 类的 Rectangle 子类,该类调用父类的构造方法,并且重写父类中的 area() 方法。代码如下:
public class Rectangle extends Figure {
Rectangle(double d1, double d2) {
super(d1, d2);
}
double area() {//方法重写
System.out.println("长方形的面积:");
return super.dim1 * super.dim2;
}
}
创建继承自 Figure 类的 Triangle 子类,该类与 Rectangle 相似。代码如下:
public class Triangle extends Figure {
Triangle(double d1, double d2) {
super(d1, d2);
}
double area() {//方法重写
System.out.println("三角形的面积:");
return super.dim1 * super.dim2 / 2;
}
}
创建 Test 测试类,在该类的 main() 方法中首先声明 Figure 类的变量 figure,然后分别为 figure 变量指定不同的对象,并调用这些对象的 area() 方法。代码如下:
public class Test {
public static void main(String[] args) {
Figure figure; // 声明Figure类的变量
figure = new Rectangle(9, 9);
System.out.println(figure.area());
System.out.println("===============================");
figure = new Triangle(6, 8);
System.out.println(figure.area());
System.out.println("===============================");
figure = new Figure(10, 10);
System.out.println(figure.area());
}
}
/*
长方形的面积:
81.0
===============================
三角形的面积:
24.0
===============================
父类中计算对象面积的方法,没有实际意义,需要在子类中重写。
0.0
*/
动态编译:类型,可扩展性
即同一个方法可以通过根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的,但可以指向对象的引用的类型很多(父类 ,有关系的类)
多态存在的条件
注意:多态是方法的多态,属性没有多态
<部分代码来源于网络>