面向对象

1.面向对象

关注对象能完成哪些功能

• 优点：耦合低，扩展力强，更易解决复杂业务逻辑，组件可复用
• 缺点：前期投入产成本高，需要进行独立体的抽取，大量的系统分析与设计
• 三大特性：封装、继承、多态

2.面向过程

关注现实的具体过程，因果关系

• 优点：对业务逻辑简单的程序可以快速开发，前期投入低
• 缺点：对复杂业务逻辑不易解决，耦合度高，一个环节出错整个系统受影响，扩展力差，没有独立体的概念，无法组件复用

3.构造器

• 和类名相同
• 无返回值
• dea快捷生成构造器alt+insert

public 类名（）{
    //无参构造
}
public 类名（）{
    this.name="zhangsan";
    //有参构造
}

一个类即使什么也不写也会存在一个无参构造（不显示），若生成了有参构造器，则默认的无参构造丢失，必须手动加上

4.封装

属性私有，加上priavte关键字，使用get和set方法去访问

class Person{
  	 private String name;//属性私有
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
 }

快捷生成get和set方法：alt+insert

在set方法中设置属性合法控制，如年龄在0~150以内

5.继承

• Java中只有单继承没有多继承，但一个父类可以有多个子类

• 类和类之间的关系

• java中所有类默认继承Object类

• 使用关键字extends

• 子类继承了父类就会拥有父类的全部方法

• 父类中私有的方法属性无法被继承

• super 用于在子类中调用父类的方法属性

• 调用子类的无参构造时会默认先调用父类的无参构造

 class Person{
    String name;
     public Person(){
          System.out.println("老师");
     }
}
 class Student extends Person{
    String no;
    public Student(){
        super();//默认存在，且只能在第一行
        System.out.println("学生");
    }
} 

//结果先打印老师再打印学生！！！！！！！！！！！！！！！

6.重写

• 只针对方法，方法名相同，参数列表相同

• 修饰符：范围可以扩大但不能缩小

  • public>Protected>Default（空）>private

• 抛出的异常：范围可以被说笑，但不能扩大

• 子类中可以重新父类中的非静态方法（实例方法）且是public！！

  class Person{
      public void say(){
          System.out.println("hello");
      }
  }
  class Student extends Person{
       public void say(){
          System.out.println("你好");
      }
  }
  public void test(){
      Student s=new Student();
   	s.say();   
  }
  //打印你好！！！！
  

• 重写后再调用以子类为准

• 快捷键：alt+insert--->override

7.多态

• 方法的多态，与属性无关

• 父类引用可以指向子类

• 父类型引用不能调用子类独有方法

  public void test(){
      Person zhangsan=new Student();//父类引用指向子类对象
      zhangsan.say();//调用重写后的方法，打印你好！！
      zhangsan.study();//编译报错，Person类型没有此方法，尽管实际对象是Student！！！
      ((Student)zhangsan).study();//通过，强制转换
  }
  class Person{//父类
      pubilc void say(){}
  }
  class Student extends Person{//子类
      public void say(){
          System.out.println("你好");//重写
      }
      public void study(){}//子类独有方法
  }
  

• 类型转换异常 ClassCastException

​ instanceof

class Person{}
class Student extends Person{} 
class Teacher extends Person{}
public void test(){
  Person p=new Student();
  Student s=new Student();
  p instanceof Person;//true
  p instanceof Student;//true
  p instanceof Teacher;//false，编译通过，Person与Teacher有父子关系，但p指向Student而非Teacher，所以false
  s instanceof Teacher;//编译不通过，Student与Teacher没有父子关系
}

向上转型：子类转化为父类，可以直接转换

​ 可能失去一些子类独有的方法

class Person{}
class Student extends Person{} 
public void test(){
 Student s=new Student();
 Person  p=s;//直接转化
}

向下转型：父类转化为子类，用强制转化

class Person{}
class Student extends Person{} 
public void test(){
 Person  p=new Student();
 Student s=(Student)p;
}

8.static

import static java.lang.Math.random;//静态导入包，后面就可以直接使用random();方法public class Person{    {//匿名代码块，在静态代码块之后执行，可用于赋初值}    static{        //静态代码块        //在类加载时执行，只执行一次    }          private static int age;//静态变量，通过类名.age访问	public static void max(int a,int b){        //静态方法，类名.max(a,b);调用        //多是功能方法，如求最大值    }     }

9.抽象类

• 在声明类或方法时加abstract关键字
• 抽象类的抽象方法必须由子类来实现，否则会编译报错
• 不能new出抽象类，只能被继承
• 抽象类里可以有普通方法，但抽象方法只能写在抽象类中
• 抽象类有构造方法，供子类使用

public abstract class Action{    public abstract void dosomethong();    //抽象方法，只有方法名，没有方法的实现}

10.接口

普通类：只有具体实现

抽象类：具体实现与规范（抽象方法）都有

接口：只有规范！！！

声明接口的关键字：interface

• 接口不能实例化，没有构造方法

• 接口里的方法默认抽象：public abstract

• 接口里的属性都默认常量：public static final

• 接口都需要实现类，实现类类名以Impl结尾

• 接口可以多继承！！！继承的多个接口以逗号分开

public interface Service{    void run();//前面默认有public abstract}public interface add{}public class UserServiceImpl implements Service,add{    public void run(){        //必须重写（实现）    }}

11.内部类

1.成员内部类

public class Demo05 {    public static void main(String[] args) {        Outer o=new Outer();        Outer.Inner in=o.new Inner();//!!!!!!!!!!!!!!!!!        o.out();        in.in();        in.getId();        in.getOut();    }}class Outer{    private int id=10;    public void out(){        System.out.println("外部类方法");    }    public class Inner{//内部类        public void in(){            System.out.println("内部类方法");        }        public void getId(){//内部类读外部类私有属性            System.out.println(id);        }        public void getOut(){//内部类访问外部类方法            out();        }    }}

2.静态内部类

public class Demo05 {    public static void main(String[] args) {        Outer o=new Outer();         }}class Outer{    private int id=10;    public void out(){        System.out.println("外部类方法");    }    public static class Inner{//静态内部类        public void in(){            System.out.println("内部类方法");        }       //静态内部类里无法访问外部类的属性和方法！！！！！！！！！！！！    }}

3.局部内部类

在方法中定义的类

public class M{
    public void m(){
        class Inner{//局部内部类
            public void in(){
                
            }      
        }
    }
}

4.匿名内部类

public class Test{
    public static void main(String[] args) {
    new Apple().eat();//匿名内部类，不用将实例保存到引用里  
    UserService u=new UserService();//???
           
    }
}
class Apple{
    public void eat(){}
}
interface UserService{
    
}