[关闭]
@liruiyi962464 2017-03-21T01:19:54.000000Z 字数 5513 阅读 473

面向对象总结

java

类

  • 类:类是由同一种事物中将相同属性和方法抽取出来封装成类,类就是一个模板,用来产生对象的模板
  • 类是抽象的定义,人类,电脑类,猫类.....

对象

  • 对象:万物皆对象,对象是具体的东西,例如一张桌子,一台电脑,一个人都是对象,
  • 对象是由类产生的,每个对象都有自己的类型,例如一个人是属于人类,桌子属于桌子类,一台电脑是属于电脑类,用户是属于用户类

类的定义:类包含属性和方法

方法的定义

  • 访问修饰符 返回值类型 方法名(参数列表){//方法体}
  • 如果返回值类型是void,就表示返回值为空,不用写return语句
  • 如果返回值类型是String ,就返回一个String类型的对象(return 一个String类型的对象)
  • 如果返回值类型是Person, 就返回一个Person类型的对象(return 一个Person类型的对象)return语句一定要写到最后一行
  • 参数的传递是属于值传递
  • 局部变量和全局变量:
  1. {
  2.     int m=10;//全局变量
  3.     public Person test(Person p){
  4.         int i=10;//局部变量
  5.         System.out.println(m);
  6.         return p;
  7.     }
  8.     public String test2(Person p){
  9.     return "姓名是"+p.getName()+",年龄是"+p.getAge();
  10.     }
  11. }

例子:定义一个Person类:

  1. class Person{
  2.     //Person类的三个属性:姓名 ,年龄,性别
  3.     String name;//成员属性
  4.     int age;
  5.     String sex;
  6.     //Person类的方法
  7.     public void say(){
  8.         System.out.pritnln("hello world");
  9.     }   
  10. }

实例化

  • 创建对象也称为实例化
  • 对象:创建对象的方法
  1. 类名 对象名=new 类名();
  2. 其中类名()是构造方法,
  3. 例子:Person p1=new Person();
  4.     Person p2=new Person();

封装

  • 类本身就属于一种封装,封装了同一类事物的属性和方法
    -使用访问修饰符private来隐藏细节也是属于封装,四种访问修饰符,权限从小到大为:private < 缺省的 < protected < public
    -使用private(私有)修饰的属性和方法只能在本类中访问和调用
    -使用public(公开)修饰的属性和方法本类对象都可以直接访问和调用

例子:

  1. class Student{
  2.     //使用private来隐藏细节,不让对象直接访问    
  3.     private String name;
  4.     private String sex;
  5.     private int age;
  6. }
  7. Student stu=new Student();
  8. stu.name;//错误,无法直接访问

getter和setter方法

  • 为私有属性提供公开的getter和setter方法来间接访问属性,给属性赋值和获取属性值

例子:

  1. class Student{
  2.     //使用private来隐藏细节,不让对象直接访问    
  3.     private String name;
  4.     private String sex;
  5.     private int age;
  6.     //给私有属性name提供公开的getter和setter方法
  7.     public void setName(String name){
  8.         this.name=name;
  9.     }
  10.     public String getName(){
  11.         return name;
  12.     }
  13.     ....
  14. }
  15. Student stu=new Student();
  16. //给name属性赋值
  17. stu.setName("lisi");
  18. //获取name属性值
  19. stu.getName();

构造方法:

  • 构造方法的特点:
    1 构造方法和类名完全相同
    2 没有返回值类型

    构造方法的功能:

  • 创建对象时会调用构造方法
  • 构造方法还可以对属性进行初始化(初始化就是给属性赋值)
  • 在类中即使不声明构造方法也会有一个默认的无参构造方法
  • 当显示的声明了一个有参的构造方法时,默认的无参构造方法就不存在了

例子:

  2. class Student{
  3.     private String name;
  4.     private String sex;
  5.     private int age;
  6. //无参的构造方法
  7.     public Student(){}
  8. //带参数的构造方法
  9.     public Student(String name,String sex,int age){
  10.         this.name=name;
  11.         this.sex=sex;
  12.         this.age=age;
  13.     }
  14. }

static关键字

  • 使用static修饰的方法和属性称为静态方法和静态属性
  • 静态方法:可以直接用类名去调用静态方法,静态方法只能访问外部的静态属性和方法,静态方法中不能出现this关键字
  • 主方法也是静态方法

例子:

  1. class Person{
  2.     static int i=10;
  3.     public static void say(){
  4.         System.out.println("hello world");
  5.     }
  6. }
  7. 可以在主方法中这样使用:Person.say();
  • 静态代码块:静态代码块优先于构造方法的执行,且只执行一次,静态代码块可以用来对外部静态属性进行初始化
  • 静态代码块在类加载的时候就被执行了
  1. static{
  2.     System.out.println("这是静态代码块");
  3. }

静态属性

  • 静态属性在内存中只存在一份,且被所有的对象所共享
  • 普通方法中也可以使用静态属性和方法

例子:

  1.     (第125行的属性)p1.i=19;//修改了静态变量的值
  2.     System.out.println(p2.i);//这个输出的是19

this关键字

  • this代表的是当前对象的引用,可以避免变量重名引起的错误
  • this();//调用的是本类无参的构造方法

例子:

  1. class Student{
  2.     private String name;
  4.     public Student(){}
  5.     public Student(String name){
  6.         this();//调用的是本类无参的构造方法,就是调用的第154的构造方法
  7.         this.name=name;
  8.     }
  9. }

方法的重载

  • 方法的重载与访问修饰符无关
  • 在Java中方法签名是唯一的,jvm是根据方法签名来判断方法是否唯一,而不是仅仅根据方法名来判断
  • 在本类中,方法签名不同
  • 方法签名是方法名+参数列表
  • 在同一个类中实现

例如:

1 2 5 6 可以构成方法的重载
1 3和4 2和7 都不能构成方法的重载
2 和3可以实现方法的重载

  1. 1 public void say(){}
  2. 2 public void say(String str){}
  3. 3 void say(){}
  4. 4 private void say(){}
  5. 5 private void say(int i){}
  6. 6 public void say(String str2,int a){}
  7. 7 public void say(String str2){}
  8. ....

String类的使用

  • 声明String的两种方法:
  1. 1 String str1=new String("abc");
  2.  2 String str2="abc";//"abc"保存在字符串常量池中
  3. String str3="abc";
  4. //str3会先从字符串常量池中去查找字符串"abc",如果存在就直接使用存在的字符串,如果没有在去创建字符串"abc"
  5. str2==str3;//true
  6. //str1是使用创建对象的方式去创建String类型的对象
  • String类方法的使用
  1.     String str = "Made In China";
  2.     String str1 = " bach";
  3.     //返回字符串的长度
  4.     System.out.println(str.length());//结果为：13
  5.     //根据指定的索引值返回对应的单个字符
  6.     System.out.println(str.charAt(0));//结果为：m
  7.     //字符串的拼接
  8.     System.out.println(str.concat(str1));//结果为： made in china  bach
  9.     //是否包含指定的字符串
  10.     System.out.println(str.contains("m"));//结果为：true
  11.     //比较字符串的大小  根据ASCII比较
  12.     System.out.println(str.compareTo(str1));//结果为：
  13.     //指定子串在字符串中第一次出现的索引值位置，默认情况是单个字符进行编号
  14.     //如果指定子串不存在则返回 -1
  15.     System.out.println(str.indexOf("m"));//结果为：0
  16.     //指定子串在字符串中最后一次出现的索引值位置，默认情况是单个字符进行编号
  17.     //如果指定子串不存在则返回 -1
  18.     System.out.println(str.lastIndexOf("a"));//结果为：12
  19.     //根据制定子串对字符串进行分割
  20.     String[] strs = str.split(" ");
  21.     System.out.println(strs[0]);//made 
  22.     System.out.println(strs[1]);//in
  23.     System.out.println(strs[2]);//china
  24.     //字符串截取1个参数的截取方式
  25.     System.out.println(str.substring(3));//结果为：e in china
  26.     //字符串截取2个参数的截取方式
  27.     System.out.println(str.substring(2,6));//结果为：de i
  28.     //将字符串中的字母全部转换成小写
  29.     System.out.println(str.toLowerCase());//结果为：made in china
  30.     //将字符串中的字母全部转换成大写
  31.     System.out.println(str.toUpperCase());//结果为：    MADE IN CHINA
  32.     //将字符串中的：“a”全部替换成A“”
  33.     System.out.println(str.replace("a", "A"));//结果为：MAde In ChinA

方法重写

方法重写注意点

  • 必须存在继承关系
  • 重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值
  • 重写的方法的访问权限要大于等于被重写的方法的权限
  • 父类中的私有方法不能被重写
  • final static修饰的方法不能被重写

方法的重载和重写的区别

  • 方法的重载的实现是在同一个类中,重写是在子父类中实现的,重写首先要存在继承关系
  • 方法的重载是要求方法签名不同,与访问修饰符无关
  • 方法的重写必须和被重写方法具有相同的方法名称、参数列表和返回值
  • 重写的方法的访问权限要大于等于被重写的方法的权限
  • 私有方法不能被重写
  • final,static修饰的方法不能被重写

包(package)

  1. 第一种导包方式
  2. import java.util.Date;
  3. 在每个类前面写上完整的包名
  4. 例如:java.util.Date today=new java.util.Date();

继承:extends

-java中只能是单继承,继承体现了 is-a 的关系
-在java中,所有的类都默认继承了Object类
-子类继承父类所有的方法和属性(私有的方法和属性不能够被继承)
-子类可以重写父类的方法(但要满足重写的规则)

例子:

  1. class Animal{
  2.     private String name;
  3.     private int age;
  4.     ....(getter and setter)
  5.     public void eat(){}
  7.     public Animal(){}
  9.     public Anima(String name,int age){
  10.         this.name=name;
  11.         this.age=age;
  12.     }
  13. }
  15. class Cat extends Animal{
  16.     public Cat(){
  18.     }
  19.     public Cat(Sting name,int age){
  20.         super(name,age);//这句必须写在第一行
  21.         //this();//这句也要写到第一行,会报错
  22.     }
  23. }

super关键字

-super:super代表的是父类对象的引用
-创建子类对象是,会默认会先调用父类的构造方法,在调用子类的构造方法
-父类如果只有带参的构造方法,子类必须要显示的去调用父类的构造方法,调用的时候必须要写在第一行
Object类:equals(),toString(),clone()//克隆 (自己解决)

多态

  • 多态是指同一操作作用于某一类对象,可以有不同的解释,产生不同的执行结果

  • 父类或者接口的引用变量可以指向子类的对象

  • 实现多态的前提:存在继承关系,有方法的重写

  • 李氏替换原则:凡是子类出现的地方都可以用父类去接收
    Animal a=new Cat();//多态的体现

  • 对象的上下转型:再向上转型的过程中,会丢失方法,Animal a=new Cat();

  • 会丢失cat独有的方法和属性,向上转型是安全的
  • 向下转型:向下转型不安全, Dog dog=(Dog)a;//会报异常

instanceof

  • instanceof :用来判断对象是否为特定类型
  • 例如 a instanceof Cat 返回boolean类型的值

动态绑定和静态绑定

  • 动态绑定和静态绑定:不能被重写的方法都是静态绑定
  • 多态的实现就是基于动态绑定

抽象类: abstract

  • 有抽象方法的类一定是抽象类,但是抽象类不一定有抽象方法
  • 抽象类不能被实例化
  • 抽象方法没有方法体
  • 非抽象子类继承了抽象类,就必须要重写抽象方法,抽象类继承了抽象类可以不重写抽象方法
  1. abstract class Animal{
  2.     public abstract void run();//抽象方法
  3. }
  • 抽象方法必须要通过子类去实例化

接口 interface

  • 接口: 代表的是has-a的关系
  1. interface InterDemo{
  2.     int a=10;//这里必须要赋初始值
  3.     public void run();//抽象方法
  4. }
  • 子类使用implements关键字去实现接口
  • 接口中只能有静态常量和抽象方法
  • 子类可以去实现多个接口,同时也可以继承其他的类
  • 接口可以继承接口
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注