Java面向对象
以类的形式组织代码,以对象的形式封装数据
类是抽象的,对象是具体的
1.抽象-定义一个类
public class Student {
//属性
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"studying");//this指代当前这个类
}
}
2.创建对象-实例化
一个类可以有多个对象
使用new关键字创建对象,除了分配空间,还会默认初始化(根据变量类型),调用类的构造器
//测试类
public class App {
public static void main(String[] args) {
//将Student类实例化 生成studentA对象
Student studentA = new Student();
System.out.println(studentA.name);//null
}
}
3.类的构造器(构造方法)
必须和类的名字相同
无返回类型,且 不能写void
public class Person {
//一个类即使什么都不写,它也会存在一个与类同名的方法(构造器)
//显式定义一个类构造器,
//1构造器可以实例化初始值
//2使用new关键字,本质是在调用构造器
String name;
public Person(){
this.name= "void";
}
//有参构造器,一旦定义了有参构造,(无参消失)使用无参就必须显式定义
public Person(String name){
this.name = name;
}
//alt + insert 快捷生成构造器 在idea中
}
//测试类
public class App {
public static void main(String[] args) {
//用new实例化一个对象
Person personA = new Person();//这里将会跳转到Person类的构造方法
System.out.println(personA.name);//void 构造器初始化为void
Person personB = new Person("cmy");//这里寻找有参构造器
System.out.println(personB.name);
}
}
4.三个特性
4.1封装
追求:高内聚,低耦合
不必将所有细节暴露,仅保留必要的接口
属性私有,get/set
//类 private私有 属性私有
public class Student {
private String name;
private int age;
private char sex;
//提供一些可以操作这些属性的方法
//提供一些public的get/set方法
//有什么用?对输入进行检查(屏蔽不合法的数据),使得系统更安全
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>150||age<0){
System.out.println("输入不合法");
}
else {
this.age = age;
}
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
/**
* @Author Void
* @Description //TODO 测试类
* 封装的意义:
* 1.使得系统更安全,保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.提高系统的可维护性
* @Date 22:22 2021/3/4
**/
public class App {
public static void main(String[] args) {
Student studentA = new Student();
// studentA.name;//无法操作,因为属性私有
studentA.setName("xiaoming");
System.out.println(studentA.getName());
studentA.setAge(-1);//输入不合法
}
}
4.2继承
继承的本质是对某一批类的抽象,从而更好的实现对世界的建模
继承是一种扩展,是类跟类的关系,子类是父类的扩展
Java中类只有单继承没有多继承
私有的无法被继承
object类
在Java中,所有的类都默认直接或间接继承Object类
super
子类默认调用父类的无参构造方法super();,所以一定父类定义了有参构造而无无参构造,子类会出问题
super();显式必须在第一行且仅存在在子类的方法\构造方法中
和this的区别
代表的对象不同:
this:代表调用者本身
super:代表父类对象
使用前提:
this:无继承也能使用
super:在继承条件下才能使用
构造方法:
this():本类的构造
super();父类的构造
方法重写
需要有继承关系,而且是子类重写父类的方法
方法名必须相同,参数列表必须相同,方法体不同
修饰符 范围可以扩大但不能缩小 public>protected>default>private
抛出的异常: 范围可以被缩小,不可被扩大 ClassNotFoundException----->Exception(大) 不允许
为什么需要重写?---->父类的功能子类不一定需要,或者不一定满足
当父类和子类有同名方法时,主要看左边实例化时声名的类型判断执行谁的方法
4.3多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
多态是方法的多态,不是属性的多态
父类和子类有联系,否则类型转换异常ClassCastException
存在条件:继承关系,方法需要重写
当father f = new son()父类的引用指向子类对象
注意以下关键字无法重写,无多态性:
1.static方法,属于类,不属于实例
2.final 常量
3.private 方法
5.instanceof
判断x和y是否有继承关系
x instanceof y
6.类型转换
Person类(父)
public class Person {
public void say(){
System.out.println("hi");
}
}
Student类(子)
public class Student extends Person{
public void run(){
System.out.println("hello");
}
}
测试类的main方法
//类型转换 父(高) 子(低)
Person p = new Student();
// p.go();//需要将父类强制转换为子类才能,使用子类的方法
Student s = (Student) p;
s.run();
//((Student)p).run();
//子类转父类可能会丢失方法
Student student = new Student();
Person p1 = student;
// p1.run();//run 丢失