Java面向对象要点

面向对象：

一、基本概念

    类与对象的基本概念：

        1、void类型是不需要返回值的，其他类型全部都需要返回值。

            public  void  tell(){}             public  int say(){ return 0; }

        2、方法的重载，方法名称不同，但是参数的类型和个数不同，通过传递参数的个数和类型不同来完成不同的功能。

    类的定义、声明及使用：

        1、类名首字母尽量大写；使用new开创内存空间。

        2、对象.属性     对象.方法      

            例如：Person p=new Person();    p.name="张三";   p.tell();

    了解面向对象

        1、面向对象和面向过程

            面向过程：不先去想做什么样的盒子，而是随机取工具制作

            面向对象：先想好做一个什么样的盒子，再取找对应的工具制作

        2、三大特征：封装、继承、多态

            封装：解决了数据的安全性问题

            继承：解决了代码的重用问题

            多态：解决了程序的扩展问题。包括方法的重载及对象的多态性。        

    方法的递归调用

        递归调用是一种特殊的调用形式，就是方法自己调用自己

            return num+addNum(num-1);

    访问权限：

        （修饰属性和方法，由大到小）

        public：公有的

        protected:受保护，父子权限：本类及其子类都可以访问，同一个包中的其他类也可以访问，不同包的子类可以访问。

        default：默认权限，只有相同包的才可以访问

        private：私有的



     静态的特点:

              和程序同生命周期；

        在没有实例化对象时，可以通过类名访问静态成员变量；

        也可以通过对象访问静态成员变量，但不论使用的是哪个对象，访问到的都是同一个变量；

        静态成员变量在声明时最好初始化，如果不进行初始化，系统会默认初始化为0。

        在成员方法前加static关键字，可以将其声明为静态成员方法；

        静态成员方法只能对类的静态成员变量进行操作；

        静态成员方法没有this引用；

        在没有实例化对象时，可以通过类名访问静态成员方法。





二、关键字

    关键字列表:

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

static关键字

        1、静态变量的定义位置在方法之外    

        2、静态变量与静态方法都是在类从磁盘加载到内存后被创建的，与类同时存在，同时消亡。

        3、静态变量又称成员变量，在类中是全局变量，可以被类中所有方法调用。

            static char sex;  static short age;    static float height;

        4、声明属性 ：声明全局属性

        5、声明方法：直接通过类名调用

        6、使用static方法时，只能访问static声明的属性和方法，而非static声明的属性和方法是不能访问的



    

    this关键字

        1、表示类中的属性和调用方法     this.getName()     this.getAge()    this.name=name;  

        2、调用本类中的构造方法        

            public People(String name,int age){

                this();     //this必须放在构造方法的首行

                this.name=name;

                this.age=age;

            }

        3、表示当前对象      比对两个对象是否是同一个对象    

            class Person{

                public void tell(){

                    System.out.println(this);

                }

            }

    

    super关键字

        1、调用父类方法   super.teach();       super(name);

        2、super不一定在重写中使用，也可以表示那些方法是从父类那里继承来的

        3、super的特点：

            super();

                super(): 表示调用父类中的构造方法

                    调用父类无参构造方法

                super(参数）：调用有参的构造方法

                super()必须放在子类构造方法的第一句

            super.成员名：

                父类的非私有成员变量



    final关键字

        final 类：最终类，不能继承

        final方法：最终方法，不能被重写

        final属性：常量，不能被修改

        常量一般放在接口中定义：    public final static 类型名



    

三、构造函数和方法



    构造函数：

        可以给对象进行初始化，当在类中自定义了构造函数后，默认的构造函数就没有了

        构造函数和一般函数在写法上有不同，在运行上也不同：

        构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加对象具备的功能。

        一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

        

    构造代码块：作用是给对象进行初始化，对象一建立就运行，而且优先于构造函数执行；构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。

        {

            System.out.println("run");

        }



    定义无参方法

        1、格式：   static void 方法名(){  方法体-方法中的代码   }

        2、代码封装在方法中，符合模块化编程，利于程序的管理和维护，重用性高。    

            input();

    定义带参方法

        1、格式：  static void 方法名（类型1 变量1，类型2 变量2，...){ 方法体-方法中的代码}    

        2、带参方法可以调用接收外界传递的数据，使方法可以处理更夹复杂的问题,具有更灵活的功能。

            static void  feeling(String cause,String content){}

    定义带返回值的方法

        1、格式：   static 返回值类型   方法名（参数列表）{ 方法中的代码    return  返回的数据}

            例： static double add(double d1,double d2){return d1+d2； }

    封装的使用

        1、保护某些属性不被外部看见，保证安全性

        2、private:私有的

        3、实现该属性的set、get方法。

            public void setAge(){ this.age=age; }

            public void getAge(){ return age; }     //使用getAge来获取

    匿名对象的使用

        1、匿名对象就是没有名字的对象，如果程序中只是用一次该对象，就可以使用匿名对象的方式。

        new Student.tell();



    构造方法

        1、格式：  访问修饰符   类名称（）{   程序语句 }

        2、构造方法名与类名相同

        3、构造方法无返回值

        4、构造方法主要是为类中的属性初始化

        5、每个类在实例化之后都汇调用构造方法，如果没有构造方法，程序在编译的时候hi创建一个无参的什么都不做的构造方法

        6、构造方法可以重载

        



    引用传递

        1、通过参数传递

    

            public static void tell(Ref1 r2)





四、抽象类



    抽象：  abstract   可以修饰类和方法，也可以里面没有任何方法。

        abstract+类：

            不能实例化，只能通过子类来继承，应用:用来表示一些抽象的算法。

            如果一个类继承抽象类，但是没有实现该类的抽象方法，则该类仍为抽象类

        abstract+方法：



    抽象类

        1、final:使用final的鳄梨不能被继承、不能被重写、不能被修改

        2、抽象类的概念：包含抽象方法的类就是抽象类

        3、抽象方法：声明而未被实现的方法，必须使用abstract关键字声明

        4、抽象类被子类继承，子类如果不是抽象类必须重写抽象类中的所有抽象方法

        5、格式：

            abstract class 类名{  

                属性    

                方法      

                抽象方法

            }

        6、抽象类不能被实例化，要通过其子类进行实例化

            abstract  class Abs{

                public abstract void say();  //抽象方法

            }

            class AbsSon extends Abs{       

                public void say(){}

            }

            public class AbsDemo{

            public static void main(String[] args){

                AbsSon as=new AbsSon();    //通过子类进行实例化

                as.say();

            }}

        7、特点：

            1、抽象方法一定定义在抽象类中，

            2、抽象方法和抽象类都必须被abstract关键字修饰

            3、抽象类不可以用new创建对象，因为调用抽象方法无意义。

            4、抽象类中的方法要被使用必须由子类复写其所有的抽象方法后建立子类对象调用，如果子类之覆盖了部分抽象方法，则该子类仍为抽象类。



五、接口

    

    接口

        1、接口可以理解为一种特殊的类，里面全部是有全局常量和公共的抽象方法所组成

        2、格式：

            interface  接口名{

                全局变量

                抽象方法

            }    

        3、接口的实现也必须通过子类，使用关键字implements，而且接口是可以多实现的。间接的弥补了java单继承的不足。

            多实现：class A implements Inter1,Inter2{}

        4、接口不能实例化，需要通过其子类才可以实例化

        5、一个类可以同时继承抽象类和实现接口

            class B extends C implements  Inter1,Inter2{}

        6、一个接口不能继承一个抽象类，但是却可以通过extends关键字同时继承多个接口，实现接口的继承

            interface Inter3 extends Inter1,Inter2{}

六、继承和多态



    继承extends

        1、解决了代码的重用性问题

        2、格式：class 子类  extends  父类{}

        3、只运行单继承

        4、不允许访问父类的非私有成员变量

        5、在子类对象实例化之前，必须先调用父类的构造方法，之后再调用子类的构造方法    super.teach();   Math.study();

    方法的重写

        1、方法名相同，返回值类型相同，参数也相同。但是实现方法不同。必须要实现继承。

        2、重写限制：子类的权限必须大于等于父类。

            puvlic > protected > default > private

        3、与重载的区别：

            重载是发生在一个类中，重写发生在继承中

            重载：方法名相同，参数的类型或个数不同

    引用的转型

        1、目标类型    变量名=（目标类型）  值；

            2、通过父类引用调用子类中特有的一个方法，无法完成,父类引用只能调用子类重写的方法。若一定要调用，则需要使用强制类型转换

            A a=new B();   //new谁就调用谁    ，隐式类型转换    向上转型   父类引用指向子类对象Father f=new Son();


            a.showInfo();

            B b=(B) a;

            b.abc();

        3、强制类型转换(显示类型转换，向下转型)  Son f=new Father();



    多态

        1、多态的体现：重写和重载

        2、对象的多态性

            class A{   //父类A

                public void tell1(){}

            }

            class B extends A{   //子类B

                public void tell2(){}

            }

            ......

            B b=new B();     A a=b;     a.tell1();      //向上转型（子类转父类），程序自动完成

            A a=new B();      B b=(B) a;  b.tell1();   b.tell2();    //向下转型，需要强制类型转换      ((A) new B)

        3、可以使用instanceof关键字判断一个对象到底是不是一个类的实例

            A a=new B();

            System.out.println(a instanceof A);

            A a1=new B();

            System.out.println(a1 instanceof A);

        4、多态的三要素：

            继承、重写、父类引用指向子类对象。（动态多态）

            重载（静态多态）

    

七、泛型

        

    泛型Generic

        1、泛型可以解决数据类型的安全问题，主要原理是：在类声明的时候通过一个标识符表示类中某个属性的类型或者某个方法的返回值及参数类型

        2、格式：

            访问权限  class  类名称<泛型，泛型..>{

                属性

                方法

            }

        3、对象的创建： 类名称<具体类型>   对象名称=new 类名称<具体类型>();

            class Point<T>{

                private T x;

                public T getX(){  return x;}

                public void setX(T x){ this.x=x }

            }

            ......

            Point<String>  p=new Point<String>();    p.setX("精度");

        4、构造方法中使用泛型：

            public Con(T value){ this.value=value; }  //写在构造方法中，加上setValue()和getValue()

            .....

            Con<Integer> c=new Con<Integer>("构造方法中使用了泛型");    //写在主函数中



        5、多个泛型的使用：

            class Gen<T,K>{

                private K key;

                private T take;

                public T getTake(){this.take=take;}

                .....

            }

            ......

            Gen<String,Integer>  g=new Gen<String,Integer> ();

                

        6、通配符的使用：？

            class Info<T>{}

            public static void tell(Info<?> i){}

        7、泛型接口：

            格式： interface 接口名称<泛型标识>{}

            例如： interface GenInter<T>{}

        8、泛型方法：

            泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型

            格式： 访问权限 <泛型标识>  方法名称([泛型标识   参数名称])    

                public <T> T tell(T t){

                    return t;

                }

        9、泛型数组：

            public static <T> void tell(T arr[]){

                for(int i=0;i<arr.length;i++){

                    System.out.println(arr[i]);

                }

            }