javaSE中级之Java面向对象一

Java面向对象一

面向对象和面向过程的区别

• 面向过程是怎么做
• 面向对象是谁来做

类和对象的关系

• 类是对对象向上抽取相同的部分
• 类是抽象的，是一个模板

类的创建

public class Xsd {
    String name;
    char sex;
    int age;

    public String show(){
        String info = "我叫"+name+"今年"+age+"性别"+sex;
        return info;
    }
}

创建对象

public class Test {
    public static void main(String[] args) {
        Xsd xsd = new Xsd();
        xsd.name = "xiaogang";
        xsd.age = 20;
        xsd.sex = '男';

        String s = xsd.toString();
    }
}

成员变量和局部变量的区别

• 代码位置不同
  • 成员变量是类中方法外定义的变量
  • 局部变量是方法中定义的变量或者代码块中定义的变量
• 作用范围
  • 成员变量是当前类的多种方法
  • 局部变量是当前一个方法或者当前代码块
• 是否要初始化
  • 成员变量不需要初始化
    • 成员变量不建议初始化，到后面使用的时候初始化最好
  • 局部变量必须初始化
• 是否有默认值
  • 成员变量有默认值
  • 局部变量没有默认值
• 作用时间
  • 成员变量是当前对象从创建到销毁
  • 局部变量是从当前方法开始执行到执行结束
• 内存位置不同
  • 成员变量是堆内存
  • 局部变量是栈内存

构造器

• new关键字实际上是调用一个方法，这个方法就是构造方法(构造器)

• 调用构造器时，在类里面没有写的话，系统会默认分配一个

• 没有任何参数的构造器叫空参构造器

• 构造器的作用不是为了创建对象

• 不建议在空构造器里面进行初始化

• 构造器格式

  //[修饰符] 构造器名字(){
  //    
  //}
  

this

• 指代的就是当前的对象
• 当属性名字和形参重名的时候，或者属性名字和局部变量重名的时候会发生就近原则

static

• static和public都是修饰符，没有先后顺序
• 在静态方法中不能访问非静态的属性
• 在静态方法中不能访问非静态方法
• 在静态方法中不能使用this关键字
• 非静态方法可以用对象名字.方法名去调用
• 静态方法可以用对象名字.方法名去调用还可以用类名.方法名调用(推荐后面这种)

代码块

• 代码块分为
  • 普通块，构造块，静态块，同步块(多线程内容)
• 类的组成有
  • 属性，方法，构造器，内部类，代码块

import

• 为了解决重名的问题
• 包名的定义规范
  • 名字全部小写
  • 公司域名倒着写
  • 不能使用系统中的关键字
  • 包的声明最上面
  • 导包是为了进行定位

权限修饰符

private

• 同一个类中可以访问
• 不同类中需要暴露接口访问
• 在不同包下的子类中不能访问

default

• 在同一个类，和同一个包中都可以访问到
• 在不同包下的子类中不能访问

protected

• 在同一个类、同一个包和同一个子类中都能访问到
• 在不同包的子类中可以访问

public

• 在一个项目中读库访问

方法重写

• 在子类中对父类的方法不满意的时候进重写
• 子类中方法名字和参数列表也要和父类一致

//父类
public class Pareson {
   public void est(){
       System.out.println("吃东西！");
   }
   public void sleep(){
       System.out.println("睡觉觉！");
   }
}
//子类
public class Student extends Pareson{
    public void study(){
        System.out.println("学习！");
    }
    public void est(){
        System.out.println("吃好吃的东西！");
    }
}

public static void main(String[] args) {
        Student student = new Student();
        student.est();
    }

重载和重写的区别

• 在不同类中，子类对父类提供的方法不满意，需要重写
• 在同一个类中，方法名相同，形参列表不同，构成重载
• 重载的修饰符，返回值与父类无关，但是方法名必须相同，参数列表可以不同
• 重写父类的权限修饰符要低于子类，父类的返回值类型要大于子类，方法名，参数列表必须相同
• 重载与重写完全没有关系

super

• 继承父类的东西

• 可以修饰属性和方法

• 在子类和父类的属性同名时就必须得加上super

• 在子类中可以通过super的属性或者方法显示调用父类提供的属性或者方法

  //父类
  public class Person {
      int age;
      public void eat(){
          System.out.println("吃！");
      }
  }
  //子类
  public class Student extends Person{
      float score;
      int age;
      public void study(){
          System.out.println("学习！");
      }
  
      public void a(){
          System.out.println(super.age);
          super.eat();
      }
      
      public void b(){
          System.out.println(age);
          eat();
      }
  }
  

super修饰构造器

• super和this修饰构造器都要放在第一行所以会起冲突
• 一旦显示的调用了super构造器系统就不会再默认分配

public class Person {
    int age;
   float soer;
   public Person(){
      //默认是不写的
   }
  public Person(int age,float soer){
       this.age = age;
       this.soer = soer;
  }
}

 public class Student extends Person{
    float score;
    public Student(){
      
    }
    public Student(float score,int age,float soer){
        //super.age = age;
        super(age, soer);
        this.score = score;   //注意this不能写到super的上面
    }

}

Object类

• Object类是所有Java类的基类
• 所有类都直接或者间接继承Object类，所有Java类都拥有Object类的属性和方法
• 在类中如果没有指明继承哪个父类，默认继承Object类

toString方法的作用

• 把这个对象以字符串形式返回
• getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
  • getClass().getName() ：返回包名+类类名完整表示，全限定路径
  • @ ：连接符号
  • Integer.toHexString(hashCode())
    • hashCode() ：把对象在堆中的地址哈希，将哈希码转到Integer.toHexString()方法中
    • Integer.toHexString() : 返回一个十六进制数对应的字符串
• toString方法的作用简单来说就是对我们的对象进行介绍，这介绍普通人不太能看得懂
• 所以需要我们对toString方法进行重写

equals方法的作用

• 对对象内容是否相等的一个比较方式
• 父类Object提供的equals就是在比较==地址，没有实际意义
• 一般不直接使用父类父类Object提供的equals，而是在子类中对这个方法进行重写
• instanceof关键字
  • 判断a对象是否是b这个类的实例，是就返回true，不是就返回false

类与类的关系

• 类和类通过将一个类作为另一个类中的方法的形参产生关系
• 继承关系
  • 一个类或者接口继承另外一个类或者接口的功能，并且可以增加它自己新功能的能力，继承关系通过关键字extends明确标识
• 实现关系
  • 一个class类实现interface接口(可以是多个)的功在代码层和关联关系是一致的，只能从语义级别类区分能，实现是类与接口之间最常见的关系，通过关键字implements明确标识
• 依赖关系
  • 依赖就是一个类a使用到了另外一个类b，而且这种使用关系是具有偶然性和临时性，是非常弱的，但是类b的变化会影响到类a，在代码层面一般让类b作为参数被类a在某个metho方法中使用
• 关联关系
  • 体现两个类之间语义级别的一种强依赖关系，这种关系不存在依赖关系的偶然性和临时性，比依赖更强，一般是长期性的，而且双方关系一般的平等的。
  • 关联可以是单向也可以是双向
  • 在代码层被关联类b以类的属性形式出现在关联类a中，也可能是关联类a引用了一个类型是被关联类b的全局变量
• 聚合关系
  • 是关联关系的一种特例，是整体与部分的关系，即has-a的关系。
  • 整体和部分是可以分离的，它们可以具有各自的声明周期
  • 部分可以属于多个整体，也可以为多个整体对象共享
  • 在代码层和关联关系是一致的，只能从语义级别类区分
• 组合关系
  • 同样是关联关系的一种特例，它体现的是一种contains-a的关系，这种关系比聚合更强，也叫强聚合
  • 体现整体与部分的关系，但是整体与部分是不可分的，整体的生命周期结束部分也随之结束
  • 在代码层和关联关系是一致的，只能从语义级别类区分