java 面向对象学习

1.面向对象:


c语言是面向过程的语言,关心具体的函数实现,java不是不关心具体函数的实现,而是在这个基础上做了一个抽象(改进),首先认为所有的方法(行为)是属于某个对象.那么面向对象首先思考的是对象和对象之间的关系，当我们思考清楚过后，我们才考虑具体的代码逻辑,也就是我们常说的过程,面向对象首先关心的是对象是否有某种行为和属性,而最后在关心函数(行为的)实现.
 
2.类和对象


访问修饰符   class  类名{
  //属性
  //方法(函数，行为）
}
类:代表的是一个类型的数据,是一个抽象的概念,是不能直接使用的.要使用类的属性和方法，必须通过类的实例对象(实实在在的具体的某一个对象)
对象的创建: new关键字来完成的.
1)类的属性如果没有手动的初始化  最基本数据类型数据值0,引用类型null  包括字符串,也是null.
2)我们的类是抽象的  必须通过具体的实例对象来调用
 
3.构造函数:


1)JDK为我们提供创建对象的一个方法().
2)格式: 访问修饰符    类名(参数列表){
       //具体的代码;
   }
//这里的参数列表可以不需要,如果没有呢  我们叫做默认的构造函数,如果有参数列表，是叫做有参构造函数.
3)假如我们不写默认的构造函数，JDK会为我们提供一个默认的实现,当我们写了一个有参构造函数，那么默认的构造函数就不能被调用,我们必须手动的写一个默认的构造函数.
4)构造函数的重构
  上面讨论的问题,其实就是构造函数的重构问题.
5）构造函数的调用,当我们调用默认构造函数或则有参构造函数的时候,只有一个构造函数被调用.
 
4.this指针

代表当前的对象(就是你目前调用的那个,谁去调用，谁就是当前对象)


package cn.ddy.java1.demo01;


public class Person {


private String name;
private int age;


public String getInfo() {
return name + "_" + age;
}
//当你写了带参数的构造函数时,必须再写一个默认的构造函数
//this 指针,  代表的是当前的对象
public Person(String name, int age) {
//System.out.println(name + age);
this.age = age;
this.name = name;
}
//默认的构造函数  不带参数的
public Person() {
}


public static void main(String[] args) {
Person per = new Person("ddy", 29);//创建了per对象后,  per的name和age已经赋值了
System.out.println(per.getInfo());
}


}


**********************************************************************
public static String address = "love";


public static String getMsg(){
return  "I love ";
}


System.out.println(Person.address);
String str = Person.getMsg();
System.out.println(str);



//继承  ,非私有的数据(  属性和方法)
//接口:  一个类实现接口通过implement  实现  
//实现父类接口,必须在子类中实现父类的方法
public class Son implements IFather {
// Son 继承 Father
public void go() {
System.out.println("子类实现go方法");
}


@Override
public void out() {
// TODO Auto-generated method stub
System.out.println("子类实现out方法");
}


public static void main(String[] args) {
// TODO Auto-generated method stub
Son son = new Son();
// son.name = "sdf";
// son.age = 23;
son.out();
// System.out.println(son.age+son.name);
}
}


/*
 * 接口:   接口不能有属性,更纯粹
 * */
public interface  IFather {
public void go();
public void out();
}


5.GC:


java为我们提供的垃圾回收机制,不需要手动去管理内存的时候.Person  person=new Person(),person=null;GC帮我们清理掉内存中的对象.
Finalize():可以简单的理解成在垃圾回收(GC)清理对象前所调用的方法
System.gc()启动垃圾回收机制(GC),不一定能启动.我们可以简单的理解成报警,报警后,警察不一定来，怀疑你假报案.
 
6.参数传递方式:值传递.
 
C:值传递,地址传递
Java：值传递.   引用数据.Person  person=new Person(), person是应用类型?是引用类型 但是不是地址
Person   person:是句柄,可以简单的理解成new  Person()这个对象的名字或则别名.   C语言操作的是堆中Person这个实实在在的对象通过地址来找到person,  java通过句柄（名字）而不是真的对象地址.
注意:虽然引用传递属于值传递,但是也可以改变句柄的值
小结:1)java对象时放在JVM的堆空间中，简单理解就是内存的一块区域
2)java引用是放在栈上的.
3）我们使用对象时通过引用来使用,我们并没有实际的操作堆中数据  比如 Person   person=new Person();person=null;意思你就是不指向任何的对象,此     时我们是不能是用person对象的。因为引用已经指向null.等待垃圾回收没有指向的person对象.


7.static关键字


 1)static可以修饰属性和方法修饰属性叫做静态的属性,修饰方法叫做静态方法
 2)静态属性和方法可以直接用对象或者类名直接调用.
 3)static直接修饰作用域叫做静态块
 4)对于java类的加载方式来说,在类的加载过程中就已经存在静态的数据,也就是用static修饰的属性，方法,静态块,而对象只有在通过new  关键字创  建后才会存在.
 5)实例方法和实例属性只有创建对象后才可以使用,那么在静态方法中使用实例的东西(属性,方法,this)是不能编译通过。在静态方法中可以创建对象.


8.Main函数


Main函数是java程序执行的入口




9.继承:


 为模拟现实世界中,父子关系的一种对象之间的关系.java提   供了这种关系的一个抽象,这种描述的抽象叫做继承.
 Extends关键字来实现继承
 1).通过子类的对象访问父类的非私有数据(属性和方法)
 
10.抽象类


 1)Abstract 关键字来定义一个类,这样的类叫做抽象类
 2)通过abstract修饰方法，而没有方法体的方法我们叫做抽象方法.如果子类要实现抽象类，那么子类必须实现父类的抽象方法.
 3)抽象类是不能用new关键字创造对象.
 4)抽象函数中可以有实例的方法.抽象类中可以不要抽象方法，
 但是这样和普通类一样，无意义.


11.接口:


Interface关键字类定义,接口比抽象类更加的纯粹,只有抽象的函数声明,没有具体的代码
1)接口中不能有属性
2)一个类实现接口通过implements关键字来实现.
3)一个类要实现父类接口,必须在子类中实现父类的方法
4)接口不能通过new 关键字来创建对象
 
12.多态性:


同一种行为表现出不同表现方式,往往呢通过继承和接口来实现.
Java面向对象有三大特性:1)封装性  2）多态性   3)继承性
Extends:
Implements:
Java的继承是单继承
Java实现接口可以实现多个.子类要实现所有接口的方法
 
重写:子类可以重新定义父类的行为方法的具体逻辑(实现)
多态性:1)可以重写来表现出不同的表现方式(统一行为).
       2)动态绑定:a.可以通过父类的引用指向子类的对象
                  b .当子类实现了父类的方法,并且重写了此方法,那么父类的句柄(引用)调用此方法的时候，会调用子类的方法.假如没有重写父类的方法,会调用父类的方法.
 
小结:继承链:1)当创建子类对象的时候先去调用父类的构造函数,然后调用子类构造函数.
           2)抽象类可以有构造函数,但是不能创建对象
           3)Super关键字可以实现父类属性和构造函数的调用.
Interface1  extends   interface2?  这个问题留给大家   思考. 
 
 
13.Final关键字


Final可以修饰类，修饰方法，修饰变量
Final可以修饰类:类是不能被继承的.
Final修饰方法:方法是不会被重写的.
Final修饰变量的时候,变量是不能再被赋值,也就是说变量是只读的
 
14.访问修饰符
       
        Private   默认(friedly)    protected    public
 本类       Y              Y           Y               Y
 同包       N              Y           Y               Y
 子类       N              N           Y               Y
其他包非子类N              N            N               Y


总结:  java的三大特性,继承,多态,封装