Java基础部分--面向对象基础（1）

一.类（class）
1.类是一组具有相同属性和行为的对象的抽象，类的作用是用来创建对象，对象是类的一个实例

2.把相似的对象划归成一个类

3.在软件设计中，类，就是一个模板，它定义了通用于一个特定种类的所有对象的属性（变量 静态特征）和行为（方法 动态特征）。

类的成员：

　　成员变量：[修饰符] 类型 属性名=[默认值]

　　　　方法：[修饰符] 返回值类型 方法名(形参列表){ 语句}

　　创建对象：类名 对象名 = new 构造器

构造器（构造方法/构造器，Constructor）
1.具有与类相同的名称
2.不含返回值类型
3.不能在方法中用return语句返回一个值
4.一般访问权限为public

构造器的作用：
1.完成对象的创建，即完成对象的实例化
2.一般使用构造器来完成对成员变量的初始化

默认的构造器:
1.在Java中，每个类都至少要有一个构造器，如果程序员没有在类里定义构造器，系统会自动为这个类产生一个默认的访问权限为public且参数列表为空的构造器

2.一旦编程者为该类定义了构造器，系统就不再提供默认的构造器

变量：

1.局部变量：定义在方法体中的变量；或是方法的形参

　　　　　　局部变量在栈内保存，栈的存取速度比堆快，效率高。

2.全局变量：即类的属性

3.静态变量：在类中声明为static 的属性

除了8种基本数据类型的变量，其他变量都是引用类型变量

　　类 （class）　　 Person p ;
　　接口（interface）　　  Animal a ;
　　数组  　　int[ ] c ;
内存的类别：
栈stack：栈的存取速度比堆快，效率高。在栈内保存基本数据类型的局部变量和对象的引用值

堆heap：堆可以保存那些对空间要求较大的变量。如对象的属性和数组的元素

类和对象的关系

1.抽象和具体的关系
2.每一个类在某一时刻都有零个或更多的实例， 类是生成对象的模板
3. 一个类定义了使用哪些数据来描述属性，每一个对象都有相应的属性值数据，一个类通过一系列方法来定义行为，这些方法能在每个对象中被激活

二.面向对象主要特征
　　I.封装（encapsulation）
1.所谓封装是把对象的属性和行为结合在一个独立的系统单位内部
2.尽可能隐蔽对象的内部细节，只向外部提供接口
3.降低对象间的耦合度
　　封装的重要意义：
1.使对象能够集中而完整地描述并对应一个具体事物
2.体现了事物的相对独立性，使对象外部不能随意存取对象的内部数据

　　II.继承（inheritance）

1.也称泛化，继承性是子类自动共享父类属性和方法的机制，在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入自己若干新的内容
2.继承简化了人们对事物的认识和描述，有益于软件复用，是OO技术提高软件开发效率的重要原因之一
3.是类之间的一种关系，一般类与特殊类之间的关系

4.子类继承父类的所有属性和方法，同时也可以增加自己的属性和方法

5.Java中只能单继承，也就是说每个类只能有一个直接父类；一个父类可以有多个子类

语法规则：

　[修饰符] class 子类名 extends 父类名

　　III.多态（polymorphism）

1.指同一个命名可具有不同的语义
2.OO方法中，常指在一般类中定义的属性或方法被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为，对于子类，可用不同的方法替代实现父类的服务的方法

方法的覆盖（override)
 重写（rewrite）
1.对从父类中继承来的方法进行改造
2.在子类继承父类时发生
方法覆盖的规则
1.在子类中的覆盖方法与父类中被覆盖的方法应具有
2.相同的方法名
3.相同的参数列表（参数数量、参数类型、参数顺序都要相同）
4.相同的返回值类型
5.子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限

 重写（Override） 特点

　　1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

　　2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

　　3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

　　4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

重载（Overload ）特点

　　1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；

　　2、不能通过访问权限、返回类型、抛出的异常进行重载；

　　3、方法的异常类型和数目不会对重载造成影响；

　　4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

•需求：点歌

Song.java

package diange;

public class Song {   //歌曲  ：模具(所有歌)

       //静态属性
     
       String  singer="薛之谦";
       String   name="丑八怪";
       String   lyric="AAAAAAAAA";
       double   price=2.00;

       //动态方法动作

}

KTV.java

package diange;

public class KTV {
    
    
      //可存歌曲
      public   Song[]   saveSong(){
            int    x[]=new int[1000];
         
            Song   songs[]=new Song[1000];  
            return  songs;
          
      }
      
      
      //向点歌机内添加歌曲
      public   void   addSong(String name,double  price  ){
          
          
      }
      
      //向点歌机内添加歌曲--向数组内赋值
      public   void   addSong(Song   s){
            
            Song  ss[]=saveSong();   //通过方法调用的到数组
            for(int i=0;i<ss.length;i++){
                if(ss[i]==null){
                    ss[i]=s;   //添加歌曲
                    break;
                }else{
                    System.out.println("内存已满");
                }
                
            }
            
      }
  
      //点歌
      public   Song   getSong(double   price){
            //实例化歌曲对象
             Song  s1=new Song();
              return   s1; 
      }
      
      //点歌
      public   Song   getSong(String  name){
          //从数组内取出歌曲
          Song   ss[]=saveSong();
          for(int i=0;i<ss.length;i++){
              if(name==ss[i].name){
                  return   ss[i];   
              }
              
          }  
          return   null;
      }

}

User.java

package diange;

public class User {  
    
    public   void  buy(){
          //调用点歌方法
           KTV  k1=new KTV();
           k1.getSong("丑八怪");
        
    }

}

•需求： 9*9乘法表

    public static void main(String[] args) {
        String s[][]=new String[9][];
        
        for(int i=0;i<s.length;i++){
            s[i]=new String [i+1];
            for (int j = 0; j < s[i].length; j++) {
            
                s[i][j]=(j+1)+"*"+(i+1)+"="+(i+1)*(j+1)+"  ";
            }
        }
        for(int i=0;i<s.length;i++){
            for (int j = 0; j < s[i].length; j++) {
                System.out.print(s[i][j]);
            }
            System.out.println();
        }