java面向对象小总结

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java面向对象小总结相关的知识,希望对你有一定的参考价值。

类:
类就是对某一事物的描述(举例:蔬菜,水果,动物)

对象:
对象就是实际存在的事物的个体,(举例:蔬菜中某一种,人类(分男人和女人))

标准类:
【类的修饰字】 class 类名称 【extends  父类名称】【implements    接口名称列表】{
变量定义及初始化;        成员变量;
方法定义及初始化;        成员方法;
}

记住:继承只能继承一个类,可以实现多个接口,
技术分享
static:静态方法,又称为类方法,static声明的变量值,所有对象使用的值都是一致的
调用静态成员变量,类名。静态成员



对象的定义:
对象的创建即对类的属性和行为的实现(类的实例化)

声明一个类的变量,就是声明了该类的一个实例,即对象,创建对象包括声明对象,实例化对象,即为对象分配存储空间两步

    类名    对象名     = new    类名();        例如:A aa = new A();            A()叫做构造函数

--------------------------------------------
方法参数传递
public int s(int x ,int y){
return ? (返回值类型)
}

引用类型传递:
public A s(A a ){
return a ;
}

-----------------------------------------------------
面向对象的三大特点:封装,继承,多态

封装:    主要实现了隐藏细节,对用户提供访问接口,无需关心方法的具体实现。

继承:    继承能很好的实现了代码复用,提高饿了编程效率
类具有继承性,子类对父类的继承关系,体现了现实世界中特殊和一般的关系。
通过继承可以更有效的组织程序结构,明确类之间的关系。并充分利用已有的类来完成更复杂,深入的开发
class    <子类>    extends    <唯一的父类名>
{
    <类定义体>
}

类之间只能单继承,不能多继承,下面这幅图:
技术分享

子类可以继承父类所有的后成员变量和成员方法,但不能继承父类的构造方法。在子类的构造方法中可使用语句super(参数列表)调用父类的构造方法。

class    Student    extends    Person
{
    public Students (String name ,int age ,String school){
        super(name ,age);        //调用父类的构造方法
        this.school    = school;
}
}

-------------
构造方法:
1,与类相同
2,没有返回值类型,不能用return
3,一般用public修饰

所有的类中都有一个默认的无参构造方法
重写构造方法后,默认的无参构造方法失效
构造函数主要用来做默认初始化

子类继承父类后
不能继承父类的构造方法,在new子类构造方法时候,默认去执行无参的构造方法
如果父类是重写为有参数的构造方法的话,子类必须重写构造方法
子类可以扩展自己成员

--------------------------------
重写和重载:

技术分享

技术分享

----------------------------------------------------------------------------------

技术分享
内部类:
package day05;
/**
 * 演示内部类1:内部类在方法外面
 * 内部类有两种,一种在方法外面,。
 * 一种在方法内部
 * 内部类可以访问外部类的成员,包括私有成员,成员包括成员变量和成员方法
 * 但是外部类不能访问内部类的成员
 * 内部类生成的.class 文件        neibu$nimei.class
 * 如果内部类没有static,里面成员不能用static修饰
 * @author yw.wang
 *
 */
public class neibu {
    private int a = 1;
    private void haha(){
        System.out.println("fuckyou!!!");
    }
    public static void main(String args[]){
        neibu n = new neibu();
        //内部类的创建。并且如果引用变量,采用就近原则
    //外部类.内部类     内部对象名 = 外部类对象.new  内部类();
        
        neibu.nimei n1 = n.new nimei();
        n1.usehaha();
        
        neibulei2 n2 = new neibulei2();
        n2.show2();
    }
    class nimei{
        //public static int a = 10;
        public void show(){
            System.out.println("我是一个show方法");
            System.out.println(a);
        }
        public void usehaha(){
            haha();
        }
    }
    static class neibulei2{
    
        public void show2(){
            System.out.println("我是第二个内部类,加了静态,相当于普通类");
        }
    }
}


内部类在方法内部:
package day05;
public class Test03 {
    public void a() {
        class xinlei {
            public void b() {
                System.out.println("哈哈");
            }
        }
        xinlei x = new xinlei();
        x.b();
        System.out.println("呵呵");
    }
    public static void main(String[] args) {
        Test03 dd = new Test03();
        dd.a();
    }
}


抽象类:
package day05;
/**
 * 演示抽象类
 * 1.用abstract修饰的类
 * 2.只有方法定义,没有方法实现,抽象方法只能出现在抽象类中
 * 3.抽象类包含抽象方法,但是也可以有普通方法,普通变量
 * 4.创建对象,不能直接new,只能new子类的的实现,
 *         子类如果想继承抽象类,必须重写所有的抽象方法,子类就不是抽象类了
 * 5.如果不重写,那么子类也是抽象类,也不可以直接new
 * @author yw.wang
 *
 */
public abstract class AbstractTest01 {
public int a = 123;
    abstract void haha();
public void hehe(){
    System.out.println("fuckyou!!!");
}
public static void main(String[] args) {
    def2 d2 = new def2();
    d2.haha();
}
}
class def2 extends AbstractTest01{
    void haha() {
//重写了抽象类父类的haha方法,现在不是一个抽象类,haha方法也不是抽象方法,所以可以直接new
        System.out.println("我重写了父类的抽象方法!!");
    }
    
}

接口:
package day05;
/**
 * 接口演示:
 * 接口只能包抽象方法和常量
 * 在接口中方法如果没写abstract修饰,那么该方法被默认是抽象方法
 * 只能new接口的实现类,也必须重写接口的抽象方法
 * @author yw.wang
 *
 */
public class InterfaceTest01 implements Interface,a,b,c {
    @Override
    //实现接口的抽象方法
    public void function() {
    System.out.println("实现了接口的抽象方法");
    }
    public static void main(String[] args) {
        InterfaceTest01 in = new InterfaceTest01();
        in.function();
    }
    
}
 interface Interface {
    public int a =10;
    public abstract void function();
    
}
interface a{}
interface b{}
interface c{}  

接口和抽象类的区别:
1,java中所有的类的父类java.lang.Object,但是接口没有共同的根
接口可以当做抽象类使用,区别如下:

1,接口中的每个方法,没有实现部分,都是抽象方法,;抽象类中可以有具体的方法

2,接口中的数据必须是常量;抽象类可以有各种类型的数据

3,由于定义在接口中所有方法都是抽象方法,接口中可以省略abstract修饰符;
但是抽象类中的抽象方法必须用abstract修饰
















































































以上是关于java面向对象小总结的主要内容,如果未能解决你的问题,请参考以下文章

Java菜鸟学习总结Java基础知识(类)

Java面向对象-面向对象编程之基本概念

Java基础总结--面向对象1

狄慧201771010104《面向对象程序设计(java)》第四周学习总结

java面向对象总结

学习总结