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，没有返回值类型，不能用return3，一般用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修饰

来自为知笔记(Wiz)