Java面向对象基础

Java面向对象学习 ———— Day3

一、类与对象

• 类的创建
  
  
  
  • 类是一个模板，是抽象的，需要实例化
    
  • 类实例化后会返回一个自己的对象
    
  1. //举例学生类的创建
  2. public class Student(){
  3.         //属性：字段 存在默认初始化
  4.     String name;
  5.     int age;
  6.     //方法
  7.     public void study(){
  8.         ...
  9.         方法体
  10.         }
  11. }

  复制代码
• 对象的创建
  必须使用new关键字创造对象
  1. //对象student
  2. Student stuent = new Student();
  3. //student就是Student类的具体实例！

  复制代码
• 构造器
  特征：和类名相同；没有返回值；
  作用：new的本质是在调用构造方法；初始化对象的值（类似c++里的构造函数）
  注意点：定义了有参构造后没有了默认的无参构造，若要使用无参构造需要显式定义一个（AIt + insert）
  1. //Student无参构造
  2. public Student(){
  3. }

  复制代码

二、封装

• 定义
  

  程序设计追求“高内聚，低耦合”。
  封装是数据的隐藏，通常应禁止直接访问一个对象中数据的直接表示，而应通过操作接口来访问。
  

  
  
• 属性私有
  类中的属性设置为私有private，需通过getter/setter（AIt + insert）来获取与设置，在类外部无法直接访问。
  

三、继承

• 定义
  

  
  
  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
    
  • 继承是类和类之间的一种关系，两个类，一个为父类（基类）一个为子类（派生类）。
    
  • 子类继承父类，就会拥有父类的全部方法；用关键字extends来表示。
    

  
  
• this / super
  
  
  
  • this ：本身调用者这个对象；没有继承也能使用
    
  • super ：父类对象的应用；只有在继承条件才能使用
    
  1. //父类
  2. public class Person {
  3.     String name = "sang";
  4.     public void test(){
  5.         System.out.println(this.name);//结果为 sang
  6.     }
  8. }
  9. //子类
  10. public class Student extends Person{
  11.     private String name = "joker";
  12.     public void print(){
  13.         System.out.println(this.name);//结果为 joker
  14.         System.out.println(super.name);//结果为 sang
  15.     }
  16. }

  复制代码
• 方法重写
  
  
  
  • 要求
    
  
  
  
  
  • 方法名必须相同
    
  • 参数列表列表必须相同
    
  • 修饰符:范围可以扩大但不能缩小 :public>rotected>Default>private
    
  • 抛出的异常:范围，可以被缩小，但不能扩大;classNotFoundException -->Exception(大)
    
  
  
  • 静态方法与非静态方法重写区别：
    
  
  
  
  
  • 静态方法其调用只和左边定义的数据类型有关，如 Student student = new Person()
    
  • 非静态方法则为方法重写
    
  
  
  • 实例：
    
  1. //父类
  2. public class Person {
  3.     public void test(){
  4.         System.out.println("sang");
  5.     }
  6. }
  7. //子类
  8. public class Student extends Person{
  9.         //方法重写（AIt + insert）
  10.     public void test() {
  11.         System.out.println("joker");
  12.     }
  13. }
  14. //main
  15. public class Application {
  16.     public static void main(String[] args) {
  17.         Student student = new Student();
  18.         Person person = new Student();
  19.         person.test();//子类重写了父类的方法，执行子类的方法 joker
  20.     }
  21. }

  复制代码

三、多态

• 定义
  

  即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
  一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多(父类，有关系的类)。
  

  
  
• 条件
  
  
  
  • 有继承关系
    
  • 子类重写父类方法
    
  • 父类引用指向子类对象
    
  
  
• instanceof
  看 System.out.println(X instanceof Y); 能否编译通过，若能通过代表X类与Y类有关系，若返回true则存在包含关系，false则不存在包含关系。
  
• 几种代码块
  1. public class Person{
  2. //2：赋初值~（第二）
  3. {
  4.     System.out.println("匿名代码块");
  5. }
  6. //1：只执行一次~（最先执行）
  7. static{
  8.         System.out.println("静态代码块");
  9. }
  10. //3：（最后）
  11. public Person(){
  12.     System.out.println("构造方法");
  13. }
  14. public static void main(string[]args){
  15.     Person person1 new Person();
  16.     System.out.println("==============");
  17.     Person person2=new Person();
  18. }

  复制代码

四、抽象类

• 目的与要求
  
  
  
  • 提供基础实现，约束子类行为
    
  • 其中可包含实例变量/静态变量/常量，具体方法 + 抽象方法（只有方法名字没有具体实现）
    
  • 不能new抽象类，抽象方法必须在抽象类中、
    
  
  
• 典型结构
  1. //抽象类 abstract
  2. public abstract class Shape{
  3.     private String color;  
  4.      public Shape(String color) {
  5.         this.color = color;
  6.     }
  7.     public abstract double area(); //抽象方法，后续子类必须实现
  8.    
  9. }

  复制代码

五、接口

• 定义与要求
  
  
  
  • 定义行为契约，解耦实现
    
  • 仅允许有public static final 常量与抽象方法（jdk8及之后支持 default/static 方法）
    
  • 可多继承
    
  
  
• 典型结构
  1. //接口 interface
  2. public interface Drawable {
  3.     // 传统抽象方法
  4.     void draw();  
  5. }
  6. //实现类
  7. public class Circle implements Drawable {
  8.     @Override
  9.     public void draw() {  // 必须重写冲突方法
  10.         System.out.println("draw");// 显式指定接口
  11.     }
  12. }

  复制代码

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除