面向对象思想(理解)
a.面向对象与面向过程对比:
面向对象注重的是结果,不注重过程
面向过程既注重过程也注重结果,面向过程得实现每个细节
举例:烤鸭:
面向过程:鸭苗慢慢养大变成鸭大
烤箱
拔毛洗鸭子掏内脏
配料涂抹鸭子
扔进烤箱拷
出炉吃胡的鸭子
面向对象:
请去全聚德
给钱
吃鸭子
面向对象的优点
1.面向对象由原来的执行者变成了指挥者(调用者,领导者)
2.面向对象思想更贴近于现实生活
3.面向对象可以讲复杂事物简单化,因为面向对象只注重结果
局部变量与成员变量
1.定义位置
局部变量:方法内
成员变量:类内方法外
2.作用域
局部变量:方法内
成员变量:整个类都能使用
3.默认值与所在内存空间
局部变量:方法栈,和方法同生(随着方法入栈)共死(方法执行完局部变量也被销毁),局部变量没有默认值,要想使用必须先赋值后使用
成员变量:堆中,和对象同生(new的时候属性存在于堆中)共死(堆中的对象被回收),有默认值
面向对象之封装
封装的体现
类:封装了属性和方法
方法:封装了很多语句
封装的好处:
1.提高代码的安全性(为年龄在setAge()加判断)
2.提高了代码的复用性(例如方法一旦定义好可以多次调用)
c.封装的实现:private,getter与setter
this关键字作用
1.为了区分成员变量和局部变量
2.谁调用成员方法,该成员方法中的this就指向谁
继承
概述
1.有继承关系的两个类必须遵循现实事物的客观规律
2.子类会自动拥有父类的所有非private修饰的成员(成员属性和成员方法)
继承的优点
1.在父类中定义的所有子类共有的属性和方法,子类继承父类,子类中就不用再重复定义
提高了代码的重用性
继承的注意事项
1.Java中的继承都是单继承
2.Java中所有的类都直接或间接继承自Object类
Java中所有的类都具有Object类中非private成员属性和方法
重载和重写对比:
权限修饰符
重载:与权限修饰符无关
重写:子类的方法的权限>=父类的方法的权限(如果父类是private,子类就不能继承,何谈重写)
方法名
重载:重载的两个方法名必须相同
重写:重写的两个方法名也是必须相同
形参列表
重载:重载的两个方法形参列表必须不同
形参类型
形参个数
形参类型的顺序
以上三点至少满足一个
重写:重写的两个方法形参列表必须相同
返回值类型
重载:重载与返回值类型无关
重写:重写的两个方法返回值必须相同
抽象类特点
1.抽象的类不能new对象
2.含有抽象方法的类一定是抽象类
3.抽象类既可以有抽象方法,也可以有非抽象方法
4.抽象类中可以没有一个抽象方法,作用
a.不想让该类创建对象
b.子类继承该抽象类,可以直接拿到抽象类中的方法使用
接口
概念
接口是一种约束,规则,规范
例如:
笔记本上的各种接口:例如USB接口,要想传输数据必须实现USB接口上的规范(设备得制作成方形,还得有4个金属触点)
电源接口:电源要么有两相,要么有三相的,这个是由电器协会规定的
特点:
1.接口中所有的方法都是抽象方法
2.接口中的变量都是常量
3.要想使用接口不能创建接口的对象,因为接口中的所有方法都是抽象方法
new 接口调用抽象没有任何意义.必须创建一个类去实现接口,然后创建该实现类的对象
定义:(重点)
interface Father{
public abstract void method();//接口中方法的修饰符,可写可不写或者写一部分
//但是在编译后方法上的修饰符一定是public abstract
void method(int i);//虽然什么都没写,最后还是要被编译器加上public abstract
public void method(double i);//虽然只写了public,最后还是要被编译器加上public abstract
public static final int a=3;//static:在类外可以直接通过Father.a来调用不用再创建对象,然后通过
//对象名来调,简化了书写
//final:被final修饰的变量是常量(恒定不变的量),一旦被final修饰,只能赋值一次
//Father.a=10;//错误,不能重复赋值
Father.a;
Father f=new Father()
new Father().a
}
接口的使用方式:
1.一个类实现一个接口
interface Father{
public abstract void method();
}
class Son implements Father{
@Override//防止忘掉重写
public void method(){
}
}
Son son=new Son();
son.method();
2.一个类只实现了接口中的部分抽象方法
interface Father{
public abstract void method();
public abstract void method2();
}
abstract class Son implements Father{//因为Son类仅实现了method()方法,而method2()这个抽象方法被继承下来没有重写
//那么这个Son类依然是抽象类(含有抽象方法的类一定是抽象类)
@Override//防止忘掉重写
public void method(){
}
}
3.一个类实现多个接口:接口中的方法都是抽象方法
interface Father{
public abstract void method();
}
interface GanFather{
public abstract void method();
}
abstract class Son implements Father,GanFather{
@Override
public void method(){//由于接口中的方法都是抽象方法,那么Father接口中的method()和ganFather中的method()方法
//同时被重写(实现)
}
}
4.一个实现继承类的同时还实现接口
interface Father{
public abstract void method();
}
interface GanFather{
public abstract void method();
}
class OldGanMother{
public void oldGanMotherJiang(){
System.out.println("老干妈牛肉酱,拌饭吃着香");
}
}
class Son extends OldGanMother implements Father,GanFather{
@Override
public void method(){
}
}
5.一个接口可以继承多个接口:因为接口中的方法都是抽象方法,没有方法体,不会存在歧义
interface Father{
public abstract void method();
}
interface GanFather{
public abstract void method();
}
interface GanDaughter extends Father,GanFather{
}
抽象类和接口对比:
相同点:
1.抽象类和接口中都可以含有抽象方法
2.都不可以直接new对象
3.都需要子类来继承或者实现
不同点:
1.接口中的方法一定是抽象方法,并且都是public abstract修饰
2.一个类只能继承一个抽象类,但是一个类可以实现多个接口
多态
概述(多种形态)
人的一生:(人的一生有很多形态,但是自始自终都是一个人)
人
宝宝,孩子,学生,程序员,丈夫,爸爸,爷爷,曾爷爷,go to dead
封装:
类和方法体现
封装提高了代码复用性
继承:
实现了父子关系,让类与类产生关系
继承提高了代码复用性,为多态提供了前提条件
多态:
父类引用指向子类对象
多态提高了代码的复用性和拓展性
构造方法(构造函数,构造器 constructor)
作用
在创建该类的对象的时候,给该类的属性赋值(初始化该类属性)
注意事项
1.如果一个类中没有写任何构造函数,编译器在编译该类后会默认添加一个空参构造
public 类名(){
}
如果手动给出的构造方法,编译器就不在添加默认构造方法,想用,手动写
2.在new对象的时候一定会找相应形参的构造方法执行
this与super
a.this关键字
1.this关键字:
a.我们可以使用this.成员变量名来区分同名的成员变量和局部变量
b.构造方法和非static修饰的方法都有this引用,谁new对象,或者是通过对象调用方法,
该方法(构造方法和成员方法)this就指向调用方法的对象 (简单来说:谁调用我,我就指向谁)
2.this(参数)//this语句:
1.this(参数)调用本类中的其它构造方法,调用的构造方法由传递参数来决定
2.this()语句一定放在构造方法的第一行,如果不写,第一行根本没有默认的this()语句
b.super关键字
1.super关键字:
a.我们可以使用 super.成员变量/super.成员方法 来使用父类的非private修饰的成员变量和成员方法
当子类的成员和父类的成员重名的时候,我们用super调用父类的成员
2.super(参数)//super语句:
a.super(参数)会自动调用父类的构造方法,调用父类哪个构造方法还是由传递的参数决定
b.super(参数)语句一定也是放在构造方法第一行,如果不写,第一行会自动添加super()语句
如果第一行已经写了this(参数)语句,super(参数)语句不再添加,虽然第一行写了this(参数)
会调用其它的构造方法,但是该构造方法依然要走父类的构造方法
3.综合案例:
public class Person {
private String name;
private String sex;
public Person(String name,String sex){
this.name=name;
this.sex=sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
public class Student extends Person {
private String sno;//学生编号
//具有姓名,性别,学号参数的构造器
public Student(String name,String sex,String sno){
super(name,sex);//将共有的属性交给父类来初始化
//而子类特有的属性自己初始化
this.sno=sno;//儿子自己的初始化动作
}
public Student(String name,String sex){
this(name,sex,"默认:110");//name,sex不再由Student(String name,String sex)来初始化
//而交给它的兄弟public Student(String name,String sex,String sno)来初始化
} //this("江旻(min)","LitteLitteBoy","默认:110")
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
public String getStuInfo(){
return super.getName()+".."+super.getSex()+".."+this.sno;
}
}
public class Demo {
public static void main(String[] args) {
Student s=new Student("山山","LittleBoy","201310101");//学生一有就
//让它具有姓名,性别,学号
System.out.println(s.getName()+"..."+s.getSex()+"..."+s.getSno());//前两个getXX方法都是Student从父类继承下来的
Student s2=new Student("江旻(min)","LittleLittleBoy");//学生一有就
//让它具有姓名,性别,学号
System.out.println(s2.getName()+"..."+s2.getSex()+"..."+s2.getSno());//前两个getXX方法都是Student从父类继承下来的
System.out.println(s2.getStuInfo());
}
}