面向对象
OOP----------面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据
从认识角度:先有对象再有类,对象是具体的事物,类是抽象的一类对象,
从代码运行角度:是先有类后有对象,类是对象的模板
三大特性
封装
类的内部数据操作细节自己完成,不允许外部干涉,仅暴露少量的方法给外部使用。高内聚,低耦合。
属性私有(private):get/set
private String name ;//名字
private int id;//学号
//提供一些可以操作这个属性的方法
//get获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置初始值
public void setName(String name){
this.name = name;
}
继承
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模,继承是类与类之间的关系,一个为父类,一个为子类。
(extands)就是扩展的意思,子类是父类的扩展。java中只有单继承,没有多继承。
注意:private不可以被子类继承,public可以被继承
在Java中,所以的类都直接或者间接继承object类
super调用父类的无参构造要放在最前面,super必须出现在子类的方法或者构造方法中,super和this不能同时出现在构造方法。
public Student() {
//隐藏代码:调用了父类的无参构造
super();//调用父类的构造器,必须要在子类的构造器
System.out.println("student无参实行");
}
super与this区别:
- 代表的对象不同:this表示本身调用者这个对象,super表示代表父类对象的应用
- 前提条件:this没有继承也可以使用,super只能在继承关系下使用
- 构造方法:this是本类的构造,super是父类的构造
重写
需要有继承关系,子类重写父类方法
- 方法名必须相同
- 参数里列表必须相同
- 修饰符:范围可以扩大: Public>protected>default>private
- 抛出的异常:范围可以缩小不能扩大:ClassNotFoundException --> Exception(大)
public static void main(String[] args) {
//静态方法与非静态的方法有很大区别
// 非静态方法可以重写
A a = new A();
a.test(); //A
//父类的引用指向了子类
B b = new A();
b.test(); //B
}
public class B {
public void test(){
System.out.println("B=>test");
}
}
public class A extends B {
@Override//注解,有功能的注释,Override:重写
public void test() {
System.out.println("A=>test");
}
}
重写,子类的方法和父类的必要一致,方法体不同
为什么需要重写:
- 父类的功能子类不一定需要或者不满足
多态
动态编译:类型:可扩展性、
定义:同一个方法可以根据发送那个对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的,但可以指向对象的引用类型有很多
注意事项:
- 多态是方法的多态,属性没有多态
- 父类和子类有联系,类型转换异常 ClassCastException!
- 存在条件: 继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();
static 方法,属于类,不属于实例 final 常量 private 方法 这些方法都不可以重写
public static void main(String[] args) {
//一个对象的实际类型确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了
Student s1 = new Student(); //student能调用的方法都是自己的或者继承父类的方法
Person s2 = new Student(); //Perso 父类型,可以指向子类,达到你是不能调用子类独有的方法
Object s3 = new Student();
//对象具体执行那个方法,主要看对象左边的类型,与右边关系不大
s2.run();
s1.run();
s1.eat();
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class Person {
public void run(){
System.out.println("run");
}
}
instanceof
//object > Person > Student
//object > Person > Teacher
Object object = new Student();
//System.out.println(X instanceof Y);
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Teacher); //false
Person person = new Student();
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Teacher); //false
抽象类
//abstract 抽象类 ;类extends :单继承 (接口可以多继承)
public abstract class Action {
//约束
//abstract ,抽象方法,只有方法名字没有方法实现
public abstract void doSomeThing();
//不能new 抽象类,只能靠子类去实现
//抽象类中可以写普通方法
//抽象方法必须在抽象类中
}
public class A extends Action {
public void doSomeThing(){
}
}
接口
interface 可以多继承
-
普通类:只有具体实现
-
抽象类:具体实现和规范(抽象方法)都有
-
接口:只有规范! 自己无法写方法 专业级的约束
定义:接口就是规范,定义的是一组规则,体现了现实世界中如果你是,则必须干什么。
接口的 本质是契约,是面向对象的精髓,是对对象的抽象。
作用:约束,定义方法让不同的人实现,接口不能被实例化,接口中没有构造方法,implements可以实现多个接口,必须重写接口中的方法
public interface UserService {
//接口中的所有定义的方法其实都是抽象的 Public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
//类 可以实现接口
//实现了接口的类,就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) { }
@Override
public void delete(String name) { }
@Override
public void update(String name) { }
@Override
public void query(String name) {}
@Override
public void timer() { }
}
构造器
类中的构造器也成为构造方法,是在进行创建对象的时候必须要调用的,并且构造器要有两个特点1:必须和类名相同2:必须没有返回值(注意也不能是void)
同时,定义有参构造后,如果想要使用无参构造,一定要显示的定义一个无参的构造
public class Person {
//构造方法,自动会生成一个方法
String name;
//实例化初始值
//1:使用new关键字,本质是在调用构造器
//用来初始化值
//无参构造
public Person(){
}
//有参构造:一旦定义了有参构造,无参构造就必须显示定义,表现出来。
public Person(String name){
this.name = name;
}
//alt + insert
}
一些快捷键
IDEA: alt + insert--------------- 快速生成构造函数
ctrl + h -------------------查看继承
ctrl + alt +T =======自动包裹代码
Typora: ctrl + shift +` ---------写代码块
ctrl +/--------------------------------源代码模式