知识点简单总结"/>
面向对象知识点简单总结
面向对象
面向对象编程:java是一门面向对象编程的语言
类和对象:对象是具体的事务,类是抽象的,类是对象的模板
-
现实生活是由很多很多对象组成的,基于对象抽出了类
-
对象:软件中真实存在的单个的个体/东西
类:类型/类别,代表一类个体(是我们自己创造的一种数据类型)
-
类是对象的模板/模子,对象是类的具体的实例
-
类中可以包含:
- 对象的属性/特征/数据-----------------成员变量
- 对象的行为/动作/功能-----------------方法
-
一个类可以创建多个对象
-
如何创建类:在idea中新建一个类,可以取名为Student,在类中添加相应的属性和方法,这样就有了一个学生类
public class Student {//成员变量String name;int age;String address;//方法void study(){System.out.println(name+"在学习...");}void sayHi(){System.out.println("大家好,我叫"+name+",今年"+age+"岁了,家住"+address);} }
-
如何创建对象:用new关键字来创建一个新的对象
Student zs = new Student(); //new新对象时会给所有的成员变量赋默认值,规则如下 byte,short,int,long,char-------------------0 float,double-------------------------------0.0 boolean------------------------------------false 引用类型------------------------------------null
-
如何访问对象中的方法:将对象实例化后,可以通过变量名.方法进行访问
zs.name = "zhangsan"; zs.age = 25; zs.address = "河北廊坊";//调用方法zs.study(); zs.sayHi();
方法:函数/过程
-
方法格式:修饰符 返回值类型 方法名(参数 参数名){方法体 return:返回值;}
-
方法的作用:封装一段特定的业务逻辑功能,尽可能独立,一个方法只干一件事,方法可以被反复调用多次,可以减少代码重复,有利于代码维护,假设有一个功能,在很多地方都得使用,就将功能封装到一个方法中
-
方法的定义:
//无参无返回值 public static void say(){System.out.println("大家好,我叫xxx,今年38岁了"); } //有参无返回值 public static void sayHi(String name){ //形参System.out.println("大家好,我叫"+name+",今年38岁了"); } //有参无返回值 public static void sayHello(String name,int age){ //形参System.out.println("大家好,我叫"+name+",今年"+age+"岁了"); } //无参有返回值 public static double getNum(){//有返回值的方法中,必须有return//并且return后数据的类型还必须与返回值类型匹配return 8.88; //1)结束方法的执行 2)返回结果给调用方 } //有参有返回值 public static int plus(int num1,int num2){int num = num1+num2;return num; //返回的是num里面的那个数//return num1+num2; //返回的是num1与num2的和 } //无参有返回值 public static int[] testArray(){int[] arr = new int[10];for(int i=0;i<arr.length;i++){arr[i] = (int)(Math.random()*100);}return arr; }
-
方法的调用
//无返回值:方法名(有参传参); say(); //调用say()方法 sayHi("zhangsan"); //String name="zhangsan" //实参 sayHi("lisi"); //String name="lisi" //实参 //有返回值:数据类型 变量 = 方法名(有参传参); double a = getNum(); //getNum()的值就是return后的那个数 System.out.println(a); //8.88,模拟对返回值的后续操作int b = plus(5,6); //plus(5,6)的值就是return后的那个数 System.out.println(b); //11,模拟对返回值的后续操作
注:只在方法中定义的参数叫形参,调用方法后的参数才是实参
-
方法的重载:发生在同一类中,方法名相同,参数列表不同
//方法重载的演示,仅为演示需要,正常操作中不会向下面这样写,类会单独分开 public class OverloadDemo {public static void main(String[] args) {Aoo o = new Aoo();o.show();o.show(25);o.show("zhangsan");o.show("zhangsan",25);o.show(25,"zhangsan");} }class Aoo{void show(){}void show(String name){}void show(int age){}void show(String name,int age){}void show(int age,String name){}//int show(){ return 1; } //编译错误,重载与返回值类型无关//void show(String address){} //编译错误,重载与参数名称无关 }
-
方法的重写(override/overriding):
-
- 发生在父子类中,方法名相同,参数列表相同
- 重写方法被调用时,看对象的类型
- 重写需遵循"两同两小一大"原则:
- 两同:
- 方法名相同
- 参数列表相同
- 两小:
- 派生类方法的返回值类型小于或等于超类方法的
- void和基本类型时,必须相等
- 引用类型时,小于或等于
- 派生类方法抛出的异常小于或等于超类方法的
- 派生类方法的返回值类型小于或等于超类方法的
- 一大:
- 派生类方法的访问权限大于或等于超类方法的
- 两同:
-
重写与重载的区别:
- 重写(override):发生在父子类中,方法名相同,参数列表相同
- 重载(overload):发生在同一类中,方法名相同,参数列表不同
-
构造器:又称构造方法,构造函数
-
构造方法:构造函数、构造器、构建器---------------复用给成员变量赋初始值代码
- 作用:给成员变量赋初始值
- 与类同名,没有返回值类型(连void都没有)
- 在创建(new)对象时被自动调用
- 若自己不写构造方法,则编译器默认提供一个无参构造方法,若自己写了,则不再默认提供
- 构造方法可以重载
-
this:指代当前对象,哪个对象调用方法它指的就是哪个对象
只能用在方法中,方法中访问成员变量之前默认有个this.
this的用法:
-
this.成员变量名----------------------访问成员变量
当成员变量和局部变量同名时,若想访问成员变量,则this不能省略
-
this.方法名()--------------------------调用方法(可以省略,没有什么情况下是不能省略)
-
this()------------------------------------调用构造方法(一般不用3
-
-
null:表示空,没有指向任何对象。
若引用的值为null,则该引用不能进行任何点操作了,若操作则发生NullPointerException空
指针异常。
-
JAVA规定:成员变量与局部变量是可以同名的,使用的时候默认采取的是就近原则,当成员变量和局部变量重名时,若想访问成员变量,则this不能省略
成员变量:写在类中方法外,作用范围为整个类
局部变量:写在方法中(包括方法的参数),作用范围为当前方法
封装、继承、多态
封装:属性私有,get/set,我们的程序要追求高内聚(类的内部数据操作细节自己完成,不允许外部干涉)、低耦合(尽量暴露少量的方法给外部使用)
get:获得这个数据
set:给这个数据设置值
作用:1.提高代码的安全性,保护数据。2.隐藏代码的实现细节。3.统一接口。4.系统可维护性增加
继承:继承的本质是对某一批类的抽象,从而实现对显示世界更好的建模
-
作用:代码复用
-
通过extends来实现继承
-
超类/父类:共有的属性和行为
派生类/子类:特有的属性和行为
-
派生类既可以访问派生类的,也能访问超类的,但超类不能访问派生类的
-
一个超类可以有多个派生类,一个派生类只能继承一个超类-------单一继承
-
具有传递性
-
java规定:构造派生类之前必须先构造超类
- 在派生类的构造方法中,若没有调用超类构造方法,则默认super()调用超类无参构造方法
- 在派生类的构造方法中,若自己调用了超类构造方法,则不再默认提供
super注意点:1.super调用父类的构造方法,必须在构造方法的第一个2.super 必须且只能出现在子类的方法或构造方法中3.super和this不能同时调用构造方法,
this和super不同:1.代表对象不同:this,本身调用者的对象,super,代表父类对象的应用
2.前提:this,没有继承也可以使用;super只能在击沉干的条件下使用
3.构造方法:this(),本类构造;super(),父类构造
方法的重写: 1.方法名必须相同,参数列表必须相同,修饰符子类要大于父类,抛出异常子类只能小于父类,重写都是方法的重写,和属性无关。
多态
多态:多种形态
-
意义:
-
同一个对象被造型为不同的类型时,有不同的功能------所有对象都是多态的(明天详细理解)
----对象多态:我、你、水…
-
同一类型的引用指向不同的对象时,有不同的实现------所有抽象方法都是多态的
----行为多态:cut()、getImage()、move()、getScore()…
-
-
向上造型/自动类型转换:
- 超类型的引用指向派生类的对象(前面是超类型,后面是派生类型)
- 能点出来什么,看引用的类型(这是规定)
- 能向上造型成为的类型有:超类+所实现的接口
-
强制类型转换,成功的条件只有如下两种:
- 引用所指向的对象,就是该类型
- 引用所指向的对象,实现了该接口或继承了该类
-
强转若不符合如上条件,则发生ClassCastException类型转换异常
建议:在强转之前一定要先通过instanceof来判断引用的对象是否是该类型
public class MultiType {public static void main(String[] args) {//条件1:引用所指向的对象,就是该类型//条件2:引用所指向的对象,实现了该接口或继承了该类Aoo o = new Boo(); //向上造型Boo o1 = (Boo)o; //引用o所指向的对象,就是Boo类型-------符合条件1Inter o2 = (Inter)o; //引用o所指向的对象,实现了Inter接口---符合条件2//Coo o3 = (Coo)o; //运行时会发生ClassCastException类型转换异常//判断o是否是Coo类型(与强转成功条件完全匹配)if(o instanceof Coo){ //falseCoo o4 = (Coo)o; //instanceof若为true,则强转一定成功}else{System.out.println("o不是Coo类型");}} } interface Inter{ } class Aoo{ } class Boo extends Aoo implements Inter{ } class Coo extends Aoo{ }
注意事项:1.多态是方法的多态,属性没有多态。2.父类和子类要有联系,否则会转换异常ClassCastExecption。3.存在条件:继承关系,方法需要重写,父类引用指向子对象;
无法被重写:static 方法,属于类,不属于实例;final 常量;private 方法
向上造型
向上造型:------------------------------------好处:代码复用
-
超类型的引用指向派生类的对象
-
能点出来什么,看引用的类型-------------这是规定,记住就可以了
多种角色能干的事都一样的时候,可以将多种角色统一造型到超类数组中,实现代码复用
访问控制修饰符:保护数据的安全
-
-
public:公开的,任何类
-
private:私有的,本类
-
protected:受保护的,本类、派生类、同包类
-
默认的:什么也不写,本类、同包类
注意:
java不建议默认权限,类的访问权限只能是public或默认的,类中成员的访问权限如上4种都可以
访问权限由大到小依次为:public–protected–默认的–private
-
数据(成员变量)私有化(private),行为(方法)大部分公开化(public)
-
成员变量分两种:实例变量和静态变量
-
实例变量:没有static修饰,属于对象的,存储在堆中,有几个对象就有几份
通过引用打点来访问
-
静态变量:由static修饰,属于类的,存储在方法区中,只有一份
通过类名点来访问
-
-
-
final:最终的、不可改变的,可以当儿子,但是不能当爸爸
-
修饰变量:变量不能被改变
//演示final修饰变量 class Eoo{final int a = 5;void show(){//a = 55; //编译错误,final的变量不能被改变} }
-
修饰方法:方法不能被重写
//演示final修饰方法 class Foo{final void show(){}void test(){} } class Goo extends Foo{//void show(){} //编译错误,final的方法不能被重写void test(){} }
-
修饰类:类不能被继承
//演示final修饰类 final class Hoo{} //class Ioo extends Hoo{} //编译错误,final的类不能被继承 class Joo{} final class Koo extends Joo{} //正确,
-
-
static:静态的
-
静态变量:
- 由static修饰
- 属于类,存储在方法区中,只有一份
- 常常通过类名点来访问
- 何时用:所有对象所共享的数据(图片、音频、视频等)
-
静态方法:
-
由static修饰
-
属于类,存储在方法区中,只有一份
-
常常通过类名点来访问
-
静态方法中没有隐式this传递,所以不能直接访问实例成员
-
何时用:方法的操作与对象无关
//演示静态方法 class Moo{int a; //实例变量(对象来访问)static int b; //静态变量(类名点来访问)void show(){ //有thisSystem.out.println(this.a);System.out.println(Moo.b);}static void test(){ //没有this//静态方法中没有隐式this传递,//没有this就意味着没有对象,//而实例变量a是必须通过对象点来访问的//所以如下语句发生编译错误//System.out.println(a); //编译错误System.out.println(Moo.b);} }//演示静态方法何时用 class Noo{int a; //实例变量----是属于对象的,描述对象的属性//在show()中需要访问对象的属性a,说明此方法与对象有关,不能设计为静态方法void show(){System.out.println(a);}//在plus()中并没有访问对象的属性或行为,说明此方法与对象无关,可以设计为静态方法static int plus(int num1,int num2){int num = num1+num2;return num;} }public class StaticDemo {public static void main(String[] args) {Moo.test(); //常常通过类名点来访问} }
-
-
静态块:
-
由static修饰
-
属于类,在类被加载期间自动执行,因为一个类只被加载一次,所以静态块也只执行一次
-
何时用:加载/初始化静态资源(图片、音频、视频等)
//演示静态块 class Poo{static{System.out.println("静态块");}Poo(){System.out.println("构造方法");} } public class StaticDemo {public static void main(String[] args) {Poo o4 = new Poo();Poo o5 = new Poo();Poo o6 = new Poo();} }
-
-
-
static final常量:应用率高
-
必须声明同时初始化
-
常常由类名点来访问,不能被改变
-
建议:常量所有字母都大写,多个单词用_分隔
-
编译器在编译时会将常量直接替换为具体的值,效率高
-
何时用:数据永远不变,并且经常使用
public class StaticFinalDemo {public static void main(String[] args) {System.out.println(Aoo.PI); //常常通过类名点来访问//Aoo.PI = 3.1415926; //编译错误,常量不能被改变//1)加载Boo.class到方法区中//2)静态变量num一并存储在方法区中//3)到方法区中获取num的值并输出System.out.println(Boo.num);//编译器在编译时会将常量直接替换为具体的值,效率高//相当于System.out.println(5);System.out.println(Boo.COUNT);} }class Boo{public static int num = 5; //静态变量public static final int COUNT = 5; //常量 }class Aoo{public static final double PI = 3.14159;//public static final int NUM; //编译错误,常量必须声明同时初始化 }
-
abstract 抽象类
-
抽象方法:
- 由abstract修饰
- 只有方法的定义,没有具体的实现(连{}都没有)
-
抽象类:
- 由abstract修饰
- 包含抽象方法的类必须是抽象类
- 抽象类不能被实例化
- 抽象类是需要被继承的,派生类:
- 重写抽象方法(变不完整为完整)-----------一般做法
- 也声明为抽象类-------------------------------一般不这么做
- 抽象类的意义:
- 封装共有的属性和行为--------------------代码复用
- 为所有派生类提供统一的类型-----------向上造型(代码复用)
- 可以包含抽象方法,为所有派生类提供统一的入口(造型之后能点出来),同时可以达到强制必须重写的目的(相当于制定一个规则)
-
设计规则:
-
将共有的属性和行为,抽到超类中------------------------抽共性
-
若派生类的行为都一样,设计为普通方法
若派生类的行为都不一样,设计为抽象方法
-
-
抽象方法/抽象类的疑问:
- 抽象方法存在的意义是什么?
- 保证当发生向上造型时,通过超类的引用能点出来那个方法-------保证能点出方法来
- 既然抽象方法的意义是保证能点出来,那为什么不设计为普通方法呢?
- 设计为普通方法,意味着派生类可以重写也可以不重写,但设计为抽象方法,可以强制派生类必须重写--------------强制派生类重写的目的
- 抽象方法存在的意义是什么?
特点:不能new这个抽象类,只能靠子类去实现它,约束;抽象类中可以写普通方法,抽象方法必须写在抽象类中
内部类
-
成员内部类:了解,应用率不高
-
类中套类,外面的称为外部类,里面的称为内部类
-
内部类只服务于外部类,对外不具备可见性
-
内部类对象通常在外部类中创建
-
内部类中可以直接访问外部类的成员(包括私有的),
内部类中有一个隐式的引用指向创建它的外部类对象-----外部类名.this—后面API中会用
//成员内部类的演示 public class InnerClassDemo {public static void main(String[] args) {Mama m = new Mama();//Baby b = new Baby(); //编译错误,内部类对外不具备可见性} }class Mama{ //外部类private String name;void create(){Baby b = new Baby(); //正确,内部类对象通常在外部类中创建}class Baby{ //成员内部类void showName(){System.out.println(name); //简写System.out.println(Mama.this.name); //完整写法//System.out.println(this.name); //编译错误,当前Baby类没有name属性}} }
-
-
匿名内部类:应用率高
- 何时用:若想创建一个类(派生类)的对象,并且对象只被创建一次,可以设计为匿名内部类,可以大大简化代码操作
- 在匿名内部类中不能修改外面局部变量的值,因为在此处该变量会被默认为final的—API时用
- 问:内部类有独立的.class字节码文件
//匿名内部类的演示 public class NstInnerClassDemo {public static void main(String[] args) {//1)创建了Aoo的一个派生类,但是没有名字//2)为该派生类创建了一个对象,名为o1----向上造型为Aoo类型// ---new Aoo(){}是在创建Aoo的派生类的对象//3)大括号中的为派生类的类体Aoo o1 = new Aoo(){};//1)创建了Aoo的一个派生类,但是没有名字//2)为该派生类创建了一个对象,名为o2----向上造型为Aoo类型// ---new Aoo(){}是在创建Aoo的派生类的对象//3)大括号中的为派生类的类体Aoo o2 = new Aoo(){};int num = 5;num = 55;//1)创建了Boo的一个派生类,但是没有名字//2)为该派生类创建了一个对象,名为o3----向上造型为Boo类型//3)大括号中的为派生类的类体Boo o3 = new Boo(){void show(){System.out.println("showshow");//num = 55; //在此处会默认外面的局部变量num为final的}};o3.show();} }abstract class Boo{abstract void show(); }abstract class Aoo{ }
接口
接口:
-
是一种引用数据类型
-
由interface定义
-
只能包含常量和抽象方法
-
不能被实例化
-
接口是需要被实现/继承的,实现类/派生类:必须重写接口中的所有抽象方法
-
一个类可以实现多个接口,用逗号分隔。若又继承又实现时,应先继承后实现
-
接口可以继承接口
/** 接口的演示 */ public class InterfaceDemo {public static void main(String[] args) {//Inter5 o1 = new Inter5(); //编译错误,接口不能被实例化Inter5 o2 = new Doo(); //向上造型Inter4 o3 = new Doo(); //向上造型} }//演示接口继承接口 interface Inter4{void show(); } interface Inter5 extends Inter4{void test(); } class Doo implements Inter5{public void test(){}public void show(){} }//演示接口的多实现 interface Inter2{void show(); } interface Inter3{void test(); } abstract class Boo{abstract void say(); } class Coo extends Boo implements Inter2,Inter3{public void show(){}public void test(){}void say(){} }//演示接口的实现 interface Inter1{void show(); //默认访问权限为public的void test(); } class Aoo implements Inter1{public void show(){} //重写接口中的抽象方法时,必须加public权限public void test(){} }//演示接口的语法 interface Inter{//接口中成员的访问权限,默认就是public的,也只能是public的public static final int NUM = 5;public abstract void show();int COUNT = 5; //默认public static finalvoid test(); //默认public abstract//int number; //编译错误,常量必须声明同时初始化//void say(){ } //编译错误,抽象方法不能有方法体 }
关系:
- 类和类--------------------------------继承
- 接口和接口--------------------------继承
- 类和接口-----------------------------实现
该内容仅用作学习和复习用,如有侵权联系删除,如有错误欢迎指正!
更多推荐
面向对象知识点简单总结
发布评论