黑马程序员---------java面向对象（自学总结）

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

1， 面向对象

2， 类  方法重载，成员方法，成员变量。

3， 非静态方法，定义，无static调用对象名.方法名。

类名 对象名=new 类名（）；

Static修饰变量，类名.xxx.

4， 包，不同包下的文件可以重名。

5， 访问级别

1） private同一个类可以访问

2） 默认的，同一个包能访问

3） Protected

4） Public 任意位置可以访问

4月2日

1， 实体类，属性

方法，构造方法。

  //构造方法——用来初始化成员变量

   //格式：

/*

   1，构造方法必须和类同名

     2,构造方法无返回值。

     this ：指的是当前对象

     3，当类中没有构造函数的时候，编译器会自动提供一个无参数的构造函数.

         其访问级别同该类本身。

   4，当我们在某一个类中自己写了其他构造函数，默认提供的就没有了。

  //重载（普通方法可以，构造方法也可以），在同一个类中，方法名一致，参数列表不一致 （参数的类型和顺序，与参数名无关）

*/   

   //this(【参数】)调用，调用该类中的其他构造函数，其中这种用法要求必须卸载构造函数的第一行。

   //当局部变量和成员变量同名的时候，又恰好在局部变量的作用域内同是使用两者是。应使用this予以区分。前面使用了this调用。

2， 在一个类中，允许出现同名的方法，但这些方法参数列表必须不一致。

3格式  对象类型数组   类型【】 数组名=new 类型【长度】；

所存储的元素是对象

4月3日

1，//成员变量

public String id;

public String name;

public int age;

public static  String test;

public static  String coutry="CN";

//构造方法

public Student(){}

public Student(String id,String name){

this.id=id;

this.name=name;

}

public Student(String id,String name,int age){

this(id,name);

this.age=age;

}

//成员方法跟对象有关。

public String printInfo(){

return "id+"+id+",name="+name+",age="+age;

}

public String study(){

return name+"在学习";

}

public static  String showClass(){

return "计算机09级";

}

//用来设置静态test的值

//非静态变量或方法属于某一个对象，例如s1修改了并不影响其他对象

//静态的对象或者方法并不属于某一个对象，它属于整个类，例如s1修改了变量或方法的内容，会影响其他对象。

1，在java语言中。类与类的继承只支持单继承（直接继承）。

2 在java语言中，如果某一个类没有显式的去继承另外一个类，

那么该类的父类是object类。

在java语言中，object类是所有类的直接或者间接父类。

4，protected 在不同包下，基于继承可以访问。

5　java语言中有三个典型的面向对象的特性：封装性、继承性和多态性，下面将详细阐述。

　1）． 封装性

　　java语言中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的状态，方法表明了对象具有的行为。通过对象的封装，实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限，实现了类中成员的信息隐藏。

2）． 继承性
　　通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继承，即一个类从多个超类派生的能力。

3）． 多态性

　　在java语言中，多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

　a) 编译时多态
　　在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。

b） 运行时多态
　　由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

重写方法调用的原则：java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。

1） 重写原则：a 方法名一致，b，参数列表一致 c,返回值一致 d:访问限制修饰符相同或者更大  e:异常（后续）。

2） 

6,　类java.lang.Object处于java开发环境的类层次的根部，其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为

　　equals() ：比较两个对象(引用)是否相同。
　　getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息。
　　toString()：用来返回对象的字符串表示。

一、多态

1，使用多态方式调用的方法，必须是父类里有的方法，如果只是子类型里包含的方法组不能通过这种方法调用

2，使用多态必须要有继承。没有继承关系的两个类，是不能写成多态形式的，但继承也可以是间接继承

3，所以object类型变量时可以存储所有java的对象类型。

4，super()关键字：当前类的父类的对象，

用法：

1、super(【参数列表】);--->调用当前类的父类的构造函数。具体调用哪一个取决于参数。

任何一个类的构造函数，只要我们自己不写this()，或者super()编译器会默认提供一个super()

而且这条语句必须出现在构造函数的第一行，所以就决定了这两句话只能写一个。

2、super.变量名，指的是调用父类的变量。一般当子类与父类出现同名变量的时候才能使用。

3、super.方法名。当子类与父类中出现同名方法的时候。

二、抽象类
在java语言中，用abstract 关键字来修饰一个类时，这个类叫做抽象类，用abstract 关键字来修饰一个方法时，这个方法叫做抽象方法。格式如下：
　　abstract class abstractClass{ …} //抽象类
　　abstract returnType abstractMethod([paramlist]) //抽象方法
1，抽象类中允许普通方法

2,抽象方法必须包含在抽象类中

3，当一个继承某个抽象类，必须"实现"（重写）该抽象类中的所有抽象方法

  除非该类也是个抽象类，name就可以选择性实现

4,抽象类的继承与普通类一样，一个类智能直接继承一个抽象类。

5，抽象类是不允许创建对象的。但允许定义构造函数

6  抽象类必须被继承，抽象方法必须被重写。抽象方法只需声明，无需实现；抽象类不能被实例化，抽象类不一定要包含抽象方法。若类中包含了抽象方法，则该类必须被定义为抽象类。

7，抽象类中可以有成员变量，用来继承用的。

三、接口

1，定义接口的关键字interface，不需要abstract关键字修饰，它是隐含的。

2，接口是一种特殊的抽象类。它是个百分之百的抽象类。接口里的方法全都是抽象方法，不允许包含普通方法

3，接口中的方法都是抽象的。

4，接口中不允许定义构造函数。

5，接口中定义的变量都是public static final的

6，接口与接口连接用extends。

7，类与接口连接使用implement

8,在java语言中，接口和接口之间可以实现多继承。

9,一个类可以实现多个接口。同时可以继承一个类。但是必须先写继承，再写实现。方法里的abstract也可以省略。

 四、final 关键字

 1 当final修饰变量的时候。该变量变成常量，也就是说该变量只能赋一次值

 2  而且当该变量是成员变量的时候，必须赋值，如果是局部变量，不使用就可以不赋值。

 五、集合list

List<String> a=new ArrayList<String>();//list不是类是一个接口.ArrayList是这个接口的一个实现类。

1、a.add("aa");//添加元素   

a.add(0, "zzz");//在指定位置添加元素。

4月10日

1， 集合的遍历方式

for(int i=0;i<a.size();i++){

System.out.println(a.get(i).length());

}//第二种遍历方式，有局限性。

for(String s:a){

    System.out.println(s.length());

}

//迭代器,是个接口类型，最重要的，最通用的形式

//hasNext():判断是否到达集合的末尾。

Iterator<String> it=a.iterator();

while(it.hasNext()){

//next()，（1）将当前指着的元素取出，（2）将标记往下移动一个位置，指向下一个元素。

System.out.println(it.next());

}

2， 重写equals方法

3， public boolean  equals(Object obj){

4，  //if(obj.getClass()==User.class&&obj!=null)//这种也可以用。

5，  if(obj instanceof  User)//这种写法是普遍使用的。

6，  {

7，      User o=(User) obj;

8，      if(this.name==o.name&&this.password==o.password&&this.age==o.age){

9，       return true;

10，      }

11，  }

12，  return false;

13，  }

14， //compareto先按年龄排序，再按照姓名排序

15， public int compareTo(User o) {

16， 

17，  if(this.getAge()-o.getAge()==0){

18， //用的是String类型的compareTo方法

19，     return this.getName().compareTo(this.getName());

20，  }else{

21，  return this.getAge()-o.getAge();

22，  }

23， 

24，  }

Collections.sort(list, new Comparator<User>() {

//

//public int compare(User o1, User o2) {

//// TODO Auto-generated method stub

////return o1.getAge()-o2.getAge();

//int n=o1.getAge()-o2.getAge();

//if(n==0){

//n=o1.getName().compareTo(o2.getName());

//}

//return n;

//}

 

 

 

六、Map<String,String> m=new HashMap<String,String>();

       m.put("1", "aa");

       m.put("2", "bb");

       m.put("3", "cc");

       m.put("5", "zz");

       System.out.println(m.get("3"));

       Set<String> key=m.keySet();

       Iterator<String> it=key.iterator();

       while(it.hasNext()){

        Object k=it.next();

        String value=m.get(k);

        System.out.println(value+"....."+value.length());

       }

七  map存储user类型

Map<Integer,User> map=new HashMap<Integer, User>();

       map.put(1, new User("aa","aa",23));

       map.put(2, new User("bb","bb",23));

       map.put(3, new User("cc","cc",23));

       map.put(4, new User("dd","dd",23));

       map.put(5, new User("ee","ee",23));

       Set<Integer> ks=map.keySet();

       for(Integer k:ks){

        User u=map.get(k);

        System.out.println(u.getName());

       }

八 Set<User>   cc=new HashSet<User>();

cc.add(new User("aa","aa",23));

cc.add(new User("bb","bb",23));

cc.add(new User("cc","cc",23));

cc.add(new User("cc","cc",24));

Iterator<User> it=cc.iterator();

while(it.hasNext()){

User u=it.next();

System.out.println(u);//注意一些方法的重写例如

}

（

public boolean equals(Object obj) {

// TODO Auto-generated method stub

if(obj instanceof User){

User u=(User) obj;

if(this.name.equals(u.name)&&this.password.equals(u.passwor   d)&&this.age==u.age){

return true;

}

}

return false;

}

public int hashCode() {

// TODO Auto-generated method stub

return name.length();

}

public int compareTo(User o) {

// TODO Auto-generated method stub

return this.age-o.age;

}

public String toString() {

return "User [name=" + name + ", password=" + password + ", age=" + age

+ "]";

}

 

）

处理异常

try{

int i=Integer.parseInt(cc);

Toast.makeText(MainActivity.this, "您输入了"+i+"", Toast.LENGTH_LONG).show();

}catch(NumberFormatException e){

Toast.makeText(MainActivity.this, "请输入一个数字",Toast.LENGTH_LONG).show();

}

4月11日

1， collection

2， list  有序，可以放重复值。

a) ArrayList

i. add(值)、add(索引，值)。

ii. remove(索引)、remove(值)。

iii. get()

iv. set()

v. 迭代器的 遍历方式

vi. Collection.sort 进行排序

vii. Collections.sort()àComparable、comparator

              3、set 无顺序，不能放重复值

a)HashSet  无序

b)TreeSet:  天生有顺序，要求放入的数据必须是有序的，如果是自己定义的类型，必须实现comparable接口。

4、Map   存储key-value

a)Map<类型一，类型二>map=new HashMap<类型一，类型二>

 

 

下午

声明异常  throws ClassNotFoundException。

捕获异常 try  catch

1、 try{

有可能会引发异常的语句

}catch(ClassNotFoundException ){

对异常处理的语句。

}finally{

不管有没有异常，都会执行的语句。

}

4月12日

1， 子类重写父类的某个方法的时候，是可以不处理父类方法的异常的。

2， 抛出和父类一样的异常，是可以的

3， 在重写是不能抛出比父类方法更多的异常。也不可以通过父类异常去代替子类异常

4， 子类可以抛出比父类方法中更精确的异常