在面向对象阶段,学习了面对对象的方法、类和对象、成员变量、局部变量、静态常量、构造方法、面对对象的三大特性(封装、继承、多态)、OBject类、访问修饰符、final关键字、抽象类(abstract)、接口类interface、static。
类和对象
类(class):具有相同属性和行为的独享的集合。
方法:描述对象的动作,在程序中,通过定义变量的像是表现属性
属性:描述对象的特征
定义类:
[修饰符] class 类名{
//属性(变量)
//行为(方法)
}
public class Car {
//定义属性
String brand;//品牌
String color;//颜色
int seat=5;//座位数
//定义行为
void go(){
System.out.println("在行驶");
}
void stop(){
System.out.println("停下来了");
}
void fly(){
System.out.println("飞起来了");
}
}
创建对象
类名 对象名=new 构造方法([参数]);
创建对象,通过"."操作符访问类中的非私有属性和方法
/*
* 创建工厂类(程序入口),该类可以创建车的对象
* */
public class Factory {
public static void main(String[] args) {
//类名 对象名 = new 类名([参数]);
//创建车类的对象c1
Car c1 = new Car();
//给对象的属性赋值
c1.brand = "宝马";
c1.color = "白色";
System.out.println("车名:" + c1.brand + ",颜色:" + c1.color + ",座位数:"
+ c1.seat);
c1.go();
c1.fly();
c1.stop();
Car c2 = new Car();
c2.brand = "五菱宏光";
c2.color = "黑色";
c2.seat = 7;
System.out.println("我有一辆" + c2.seat + "座的" + c2.color + c2.brand);
}
}
类和对象的关系
对象是类的具体表现,类是对象的集合(模板)
先定义类,才能通过该类创建对象
成员变量、局部变量、静态常量
成员变量
定义在类中的变量,称为成员变量,拥有默认值
成员变量随着对象的创建而存在没随着对象的回收而销毁。作用范围在类内部。成员变量有初始值。
public class Car{
String brand;//这就是一个成员变量,默认值为null
void info(){
//这里brand虽然没有赋值,但是它是一个成员变量,属于引用类型,默认值为null
System.out.println("车名:"+brand);//如果不赋值,最终打印"车名:null"
}
}
局部变量
定义在方法中的变量,称为局部变量。默认没有默认值,赋值之后才能使用
局部变量随着类的加载而存在,随着方法的执行结束而销毁。作用范围在方法内部。
public class Test{
public static void main(String[] args){
//这里的num和name就是一个局部变量,没有默认值
int num;
System.out.println(num);//这里无法通过编译,因为num没有赋值
String name="小明";
System.out.println(name);//这样才能正常输出
}
}
静态常量
被final、static修饰的成员变量
静态常量随着类的加载而存在,随着类的销毁而销毁。作用范围在程序周期中。静态常量有初始值
构造方法
它是一个特殊的方法,没有返回值,方法名和类名一致,每一个类在定义时,都有一个默认隐藏的无参数的构造方法,在创建对象时调用。构造方法通常用于初始化成员变量。
public class 类名{
//这是无参构造方法,默认就会存在,不过是隐藏的
public Test(){
}
}
特点:
构造方法没有返回值(没有返回值这一部分,不是void),构造方法名必须和类名相同
每个类默认有一个隐藏无参数的构造方法,方法体中没有内容,用于创建无参数的对象
三大特性:封装、继承、多态
封装
继承
方法重写Override
当子类继承父类后,可以对父类中的非私有的方法进行扩展或覆盖,这个过程称为重写。
要求:
方法名、参数列表、返回值必须和父类一致
访问权限不能比父类更严格
不能抛出比父类更大的异常
方法重载overload
在一个类中,多个方法的方法名相同,参数列表不同时,这些就是重载的方法。即同名不同参
要求
方法名相同
参数列表(类型和数量)不同
与返回值无关
this和super关键字
可以当作对象使用,也可以当作构造方法使用
当对象使用:"this.属性"或"this.方法"或"super.属性"或"super.方法"
此时的this或super表示“当前类”或“父类对象”
public calss Person{
private String name;
public void setName(String name){
this.name=name;//这个this表示当前类Person的对象
}
}
当构造方法用:"this([参数])或super([参数])"
public class Person(){
private String name;
private int age;
public Person(){
//这句话表示调用Person(String name,int age)构造方法,只能放在第一行
this("小明",20);
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
注意
Object类
它是所有类的父类,任何类都可以间接地继承了该类,但没有明确的在extends中体现出来。所有类都可以访问Object类中的方法,或对其进行重写。
向上转型
Person p = new Person();
Object obj=p;
向下转型
Animal an = new Animal();
Cat c=(Cat)an;
多态
public class Father{
}
public class Son extends Father{
}
public class Main{
public static void main(String[] args){
Son son = new Son();
//这就是多态的体现
//子类的对象,可以使用父类的变量保存
Father father = new Son();
}
}
访问修饰符
访问权限表
final关键字
用于修饰属性、方法和类 。当final修饰属性时,该属性的值不可更改。
修饰属性:变量成常量,不能改变其中的值。
修饰方法:方法称为最终的方法,不能重写。
修饰类:类称为最终类,不能被继承。
在属性前加上final,这时的属性称为常量。常量命名时,所有字母都要大写,多个单词用_隔开。
final 数据类型 常量名;
final NUM=123;
修饰方法:该方法不能被重写。在返回值前面加上final
public class Father{
public final void fun(){
}
}
修饰类时,该类不能被继承,在class前面加上final
public final class Father(){
}
//提示错误,该类不能被继承
public class Son extends Father{
}
抽象类(abstract)
修饰方法: 访问修饰符 abstract 返回值类型 方法名(参数类型 形参名称);
//当一个类中有抽象方法时,该类也需要是一个抽象类
public abstract class Game{
//这就是一个抽象方法,没有方法体
public abstract void startGame(Player player);
}
修饰类: 访问修饰符 abstract class 类名{}
如果一个类中有抽象方法,这个类必须也是一个抽象类。
抽象类不能被实例化(不能创建对象)。
抽象类中,可以存在非抽象方法,如getter/setter或构造方法。
当抽象类的构造方法执行时,不会创建对象。
接口interface
public interface 接口名{
//接口中只能定义公开的静态常量且要赋值,默认用public static final修饰
double PI = 3.14;
//接口中的方法默认用public abstract修饰,表示公开的抽象方法
void fun(String name);
//接口中不能定义普通方法
//void fun1(){}
//jdk1.8之后,接口中可以定义默认方法或静态方法,有方法体
defult void fun2(){
}
}
static (静态的)
是一个修饰符,可以修饰属性、方法、代码块。
被static修饰的内容,被称为静态成员。静态成员在类加载的时候,就会保存到内存中,可以脱离对象存 在。 所以访问静态成员时,可以不用创建对象,直接通过类名访问。
特点
静态方法中只能使用静态成员,不能使用非静态成员。
非静态方法中可以使用静态成员。
静态方法中,不能使用this关键字。