java基础
一. 方法
1.1 方法的定义和调用:
1).方法内部实现功能时,是否需要外部数据(来决定是否需要参数);
2).方法内部实现功能后,是否有运行结果(来决定是否需要返回值);
public static void main(String[] args) {
int sum = getSum(7, 6);//7和6叫“实参”
System.out.println(sum);
}
public static int getSum(int a,int b){//a和b叫"形参"
return a+b;
}
1).形参:在“定义”方法时的参数叫:形参(形式参数)。格式:数据类型 变量名
2).实参:在“调用”方法时传递的真实的参数数据较:实参(实际的参数)。格式:方法名(实参);
1.2方法的重载
方法重载:指在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可,与修饰符和返 回值类型无关。
参数列表:个数不同,数据类型不同,顺序不同。
重载方法调用:JVM通过方法的参数列表,调用不同的方法。
public static void main(String[] args) {
sum(10,20);
sum(10,20,30);
sum(3.14,5.6);
}
public static void sum(int a ,int b){
System.out.println(a + b);
}
public static void sum(int a ,int b,int c){
System.out.println(a + b + c);
}
public static void sum(double a ,double b){
System.out.println(a + b);
}
二. 封装
- 使用 private 关键字来修饰成员变量。(只在本类中才能访问)
- 对需要访问的成员变量,提供对应的一对 getXxx 方法 、 setXxx 方法。
private 数据类型 变量名 ;
2.1. -----this
使用 private 修饰成员变量:
public class Student {
private String name;
private int age;
}
提供 getXxx 方法 / setXxx 方法,可以访问成员变量
public void setName(String name) {
//name = name; 错误,这里访问的name都是"参数的name"。不是成员的name属性。
this.name = name;//this.name表示成员的name属性;name表示参数的name
}
public String getName() {
return name;//这里可以不用this,因为也没有"同名的局部变量”,所以可以直接找到成员的name。也可以用
}
public void setAge(int age) {
//age = age; 错误
this.age = age;
}
public int getAge() {
return age;
}
2.2. -----构造方法
修饰符 构造方法名(参数列表){ // 方法体 }
public class Student {
private String name;
private int age;
// 无参数构造方法‐‐用于创建对象时无参构造:
Student stu = new Student();
public Student() {}
// 有参数构造方法‐‐用于创建对象时带参构造:
Student stu = new Student("高圆圆",18);
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
- 如果不提供构造方法,系统会给出无参数构造方法。
- 如果提供了构造方法,系统将不再提供无参数构造方法。
- 构造方法是可以重载的,既可以定义参数,也可以不定义参数。
三. 继承
3.1 继承
就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。
extends 关键字
父类 员工类Employee
class Employee {
String name; // 定义name属性
// 定义员工的工作方法
public void work() {
System.out.println("尽心尽力地工作"); }
}
}
定义老师类Teacher 继承 员工类Employee
class Teacher extends Employee {
public void printName() {
System.out.println("name=" + name);
}
}
定义测试类
public class ExtendDemo01 {
public static void main(String[] args) {
Teacher t = new Teacher();
t.name = "小明"; // 调用该员工的printName()方法
t.printName(); // name = 小明
// 调用Teacher类继承来的work()方法
t.work(); // 尽心尽力地工作
}
}
- Java只支持单继承,不支持多继承。
//一个类只能有一个父类,不可以有多个父类。
class C extends A{} //ok
class C extends A,B... //error
- Java支持多层继承(继承体系)。
class A{}
class B extends A{}
class C extends B{}
- 子类和父类是一种相对的概念。
子父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用 super 关键字,修饰 父类成员变量
super.父类成员变量名
3.1.方法重写
如果子类父类中出现重名的成员方法,叫做方法重写 (Override)。
方法重写 :子类中出现与父类一模一样的方法时(返回值类型,方法名和参数列表都相同,会出现覆盖效果也称为重写或者复写。
父类:
class Phone {
public void sendMessage(){
System.out.println("发短信");
}
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("来电显示号码");
}
}
子类:
//智能手机类
class NewPhone extends Phone {
public void showNum(){
super.showNum();
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
}
测试类
public class ExtendsDemo06 {
public static void main(String[] args) {
NewPhone np = new NewPhone();
// 调用父类继承而来的方法
np.call();
// 调用子类重写的方法
np.showNum();
}
}
- 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。
- 子类方法覆盖父类方法,返回值类型、函数名和参数列表都要一模一样。
四.多态
4.1 多态的体现
多态: 是指同一行为,具有多个不同表现形式。
父类类型 变量名 = new 子类对象; 变量名.方法名();
父类类型:指子类对象继承的父类类型,或者实现的父接口类型。
父类
public class Animal {
public void eat(){
System.out.println("动物都要吃饭")
};
}
子类
class Cat extends Animal {
//重写父类的方法
public void eat() {
System.out.println("吃鱼");
}
}
class Dog extends Animal {
//重写父类的方法
public void eat() {
System.out.println("吃骨头");
}
}
测试类
public class Test {
public static void main(String[] args) {
Animal a1 = new Cat();
a1.eat();
Animal a2 = new Dog();
a2.eat();
}
}
4.2 引用类型转换
4.2.1.向上转型
多态本身是子类类型向父类类型向上转换的过程,这个过程是默认的。
当父类引用指向一个子类对象时,便是向上转型。
父类类型 变量名 = new 子类类型(); 如:Animal a = new Cat();
4.2.2 向下转型
父类类型向子类类型向下转换的过程,这个过程是强制的。
一个已经向上转型的子类对象,将父类引用转为子类引用,可以使用强制类型转换的格式,便是向下转型。
子类类型 变量名 = (子类类型) 父类变量名; 如:Cat c =(Cat) a;
eg:
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 判断a是否是Cat类型
if (a instanceof Cat){
Cat c = (Cat)a; //向下转型
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
//判断a是否是Dog类型
Dog d = (Dog)a; //向下转型
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}