Jvaa三大特性知识笔记

什么是面向对象?

OOP

面向对象就是以类的方式组织代码,以对象的组织(封装)数据.

三大特性:

  1. 继承

  2. 多态

  3. 封装

 

Java封装( private)

该露的露,该藏的藏

程序设计追求高内聚低耦合, 高内聚就是类内部数据操作细节自己,不允许外部干涉,低耦合,仅暴露少量的方法给外部使用

封装(数据的隐藏)

通常,应禁止直接访问一个对象中的数据表示,而应该通过接口访问,这称为信息隐藏

属性私有,get/set

属性:

名字 学号 性别 private

public class Student {
​
    private String name;
        private int id;
        private char sex;
        
/**
         * @return the id
         */
        public int getId() {
            return id;
        }
        /**
         * @param id the id to set
         */
        public void setId(int id) {
            if(id>120|| id<0) {
                this.id = 3;
            }else {
                this.id=id; 
            }
            
        }
        /**
         * @return the sex
         */
        public char getSex() {
            return sex;
        }
        /**
         * @param sex the sex to set
         */
        public void setSex(char sex) {
            this.sex = sex;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name=name;
        }
​
​
}
package cn;
​
public class Application {
        //提高程序的安全性,保护数据,
//  隐藏代码实现的细节,统一接口,系统可维护增加了
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    Student s1=new Student();
        s1.setName("项羽");
        System.out.println(s1.getName());
        s1.setId(888);
        System.out.println(s1.getId());
    }
​
}

 

​

java继承(extends)

继承本质是对某一批的抽象,从而实现对现实世界更好的建模

extends :扩展 子类父类拓展

在java中所有的类,都默认直接或者间接继承object

java中类只有单继承,没有多继承,一个儿子只能有一个儿子,一个爸爸可以有多个儿子

super注意点:

1.super调用父类的构造方法,必须构造方法的第一个!

2.super 必须能出现在子类的方法或者构造方法中!

3.super 和this 不能同时调用构造方法!

Vs this

代表的对象不同

  1. this.本身调用者这个对象

  2. super:代表父类对象的应用

前提

  1. this:没有继承也可以使用

  2. supper:只能继承条件才可以使用

构造方法

  1. this()本类的构造:

  2. super()父类的构造

java方法重写(extends)

 

重写:需要有几种关系,子类重写父类的方法!

  1. 方法名必须相同

  2. 参数列表 列表必须相同

  3. 修饰符:范围可以扩大:private<Default<Protected<public

  4. 抛出异常:范围,可以被缩小,但不能被扩大 ClassNotFoundException>> Exception(大)

重写,子类方法和父类必须一致,方法体不同!

为什么需要重写?

  1. 父类功能子类不一定需要或者不一定满足

  2. Alt+Insert ; override; 重写按键

 

public class A extends B{
​
        public  void test(){
            super.test();
        }
}
​
​
public class B {
​
    public  void test() {
        System.out.println("Btest");
    }
}
public class Application {
​
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        A a=new A();
        a.test();
        
        B b=new B();
        b.test();
    }
​
}

 

java多态

​
public class Person {
    public void run() {
        System.out.println("你好像有那大病");
    }
package com.demo01;

 

 



//多态注意事项:
//多态方法的多态,属性没有多态
// 父类子类,有联系类型转换异常 classCsstException
// 继承关系,方法需要重写 父类引用指向子类对象 Father son=new Son();
//方法不能重写:
//    static 方法属于类 不属于实列
//    final 常量
//    private方法



public class Student extends Person{
    @Override
    public void run() {
        super.run();
    }
    public void eat(){
        System.out.println("我会sei");
    }
}




 




package com.demo01;
​
public class Application {
    public static void main(String[] args) {
//        一个对象的实际类型是确定的
//        new Student();
//        new Person();
//        可以指向引用类型就不确定了
​
        //父类的引用指向类  能调用的方法都是自己的或者继承父类的
        Student student = new Student();
//        person父类型,可以转向子类,但不能调用子类独有的方法
        Person student2 = new Student();
        Object student3 = new Student();
        student.run();
        //高转低 从高类型转到低类型
        ((Student) student2).eat();
​
    }
​
}




 


 


多态条件 :


    

  1. 

     有继承关系
    

    2. 

  2. 

    子类重写父类的方法
    

    3. 

  3. 

     父类引用指向子类对象
    

    4. 



多态的方法是多态,属性没有多态性


 


java抽象类(abstract)


#### 




//abstract抽象类   类 单继承   接口可以多继承
public abstract class Action {
​
//    约束有人帮我们实现
//    abstract 抽象方法 只有方法名字 没有实现方法的实现
    public abstract void doSomething();
​
//    1.不能new这个抽象类  只能靠子类去实现他;约束
//    2.抽象类 中可以写普通的方法
//            3.抽象方法必须在抽象类中
//    4.抽象的抽象:约束
}
package com.demo02;
//抽象类的所有方法,继承了他的子类都必须实现他的方法
public class A extends Action{
    @Override
    public void doSomething() {
​
    }
}




 


 


思考题?


 抽象类不存在new 对象,那存在构造器吗? 


 抽象类存在的意义?? 抽象出来 提高开发效率


java内部类


学习地址:https://www.cnblogs.com/chenssy/p/3388487.html


可以将一个类的定义放在另一个类的定义内部，这就是内部类。


初次认识无非就是在一个类的内部定义一个类




package demo03;
​
public 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);
        }
        }
}




 



​


为什么要使用内部类?


    

  • 

    在我们程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
    

    • 



注意事项:


java类中 可以有多个class,但只能有一个public class


    

  • 

    成员内部类,
    

    • 

  • 

    局部内部类
    

    • 

  • 

    匿名内部类
    

    • 

  • 

    静态内部类
    

    • 



java异常处理


什么是异常?


程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。异常发生时，是任程序自生自灭，立刻退出终止。在Java中即，Java在编译或运行或者运行过程中出现的错误。


![image-20210727102112706](C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210727102112706.png)


异常处理机制:


    

  • 

    抛出异常:::::::当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
    

    • 

  • 

    捕获异常:::::::在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。 
    

    • 



异常处理五个关键字


 try, catch,finally,throw,thorws






            

            
posted @ 
2021-07-28 09:58 
苏先生呀 
阅读(205) 
评论(0) 
 
收藏 
举报