面向对象三大特性
封装
封装:属性私有,get/set 有时候在set方法中会做一些安全性验证的判断
封装的意义:
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统的可维护性增加
注意:判断两个方法是否相同,看方法名和参数列表
package oop.demo01.demo03;
//类 private:私有
public class Student {
//属性私有
private String name;
private int id;
private char sex;
private int age;
//提供一些可以操作这个属性的方法
//提供一些public 的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
//alt+insert 自动生成getset方法的快捷键
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package oop.demo01;
import oop.demo01.demo02.Person;
import oop.demo01.demo03.Student;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("大白");
System.out.println(s1.getName());
}
}
快捷键:alt+insert 自动生成getset方法的快捷键
继承
在Java中,所有的类都直接或间接继承Object
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中!
3.super和this不能同时调用构造方法!
this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的引用
前提
this:没有继承也可以使用
super:只能在继承条件下 才可以使用
构造方法
this();本类的构造
super();父类的构造
重写
1.重写:需要有继承关系,子类重写父类的方法。重写是针对方法的。
是与子父类有关,而且是子类重写父类的方法。
(1)方法名必须相同
(2)参数列表必须相同
(3)修饰符:范围可以扩大但不能缩小。public>protected>default>private
(4)抛出的异常:范围,可以被缩小,但不能扩大。
注意:(1)方法重写只能用于非静态方法,并且要有继承关系。
(2) 重写,子类的方法和父类的方法必须要一致;方法体不同。
2.为什么需要重写?
-
父类的功能,子类不一定需要,或者不一定满足。
-
快捷键:Alt+Insert,然后选中override。
3.方法重载:是在本类中的。
多态
父类
package oop.demo01.demo05;
public class Person {
public void run(){
System.out.println("run");
}
}
子类
package oop.demo01.demo05;
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
}
运行类
package oop.demo01;
import oop.demo01.demo05.Student;
import oop.demo01.demo05.Person;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//可以指向的引用类型就不确定了,父类的引用指向子类
//Student 这个子类,能调用的方法都是自己类中定义的或者是继承父类的
Student s1 = new Student();
//Person 父类型,可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法,主要看对象左边的类型,和右边关系不大!
s2.run();//子类重写了父类的方法,执行子类的方法;子类和父类都有同一个方法时,执行子类中的该方法
s1.run();
}
}
多态注意事项:
1.多态是方法的多态,属性没有多态;
2.父类和子类,有联系;如果出现类型转换异常,会报错ClassCastException
3.存在条件:继承关系,方法需要重写,父类引用指向子类对象。如Father f1= new Son();
不能重写的方法有:
(1)static方法,即静态方法,静态方法属于类,它不属于实例;
(2)final 常量修饰符;
(3)private方法;
instanceof 和 类型转换
instanceof (类型转换) 引用类型,判断一个对象是什么类型,判断两个类之间是否存在父子关系。
父类:
package oop.demo01.demo05;
public class Person {
public void run(){
System.out.println("run");
}
}
子类:
package oop.demo01.demo05;
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
}
package oop.demo01.demo05;
public class Teacher extends Person{
}
运行工具类:
package oop.demo01;
import oop.demo01.demo05.Student;
import oop.demo01.demo05.Teacher;
import oop.demo01.demo05.Person;
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Teacher
//Object > Person > Student
//父类 > 子类 > 子类
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
}
}
note:
1.父类引用指向子类的对象;
2.把子类转换为父类,向上转型;
3.把父类转换为子类,向下转型;强制转换,可能会丢失一些方法。
4.方便方法的调用,较少重复代码。
static 关键字
非静态方法可以调用静态方法。
package oop.demo01.demo06;
public class Person {
//程序在执行时不能直接调用这个匿名代码块,匿名代码块是创建这个类的对象时才自动创建,且在构造器之前
{
//代码块(匿名代码块)
}
//静态代码块是类一加载就直接执行,永久只执行一次
static{
//静态代码块
}
//对象一创建就会先执行匿名代码块,然后执行构造方法 ,静态代码块只执行一次
//2:赋初值
{
System.out.println("匿名代码块");
}
//1:只执行一次
static {
System.out.println("静态代码块");
}
//3
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person p1 = new Person();
System.out.println("====================");
Person p2 = new Person();
}
}