一切世界上存在的事物都可以看成是一个对象,面向对象的思想更符合我们人的思考方式.每个对象都有自己的属性和功能,这对应了类的成员变量和类中的方法。面向对象的知识有继承、多态、抽象类、接口，在学习的过程中，要了解一个类的初始化过程，以及变量在内存中的位置(在堆还是在栈里还是其它的)。
Java中一个类的定义：
public class Baidu{
private final String COMPANY_NAME =“百度”;
//CEO
private String president = “李彦宏”;
private void setPresident(String name){
This.president = name;
}
private String getPresident(){
return this.president;
}
public String searchSomething(String what){
return “百度一下：”+what;
}
}一个类的成员变量一般都会将它定义为私有的即private，然后给外部提供了相应的set和get方法，这其实是一种封装的思想，这样做的好处是增强系统的安全性。就像笔记本一样，封装起来只提供一个USB接口，这样防止里面的零件被随意破坏。
一个类的继承：一个类只能继承一个类,也就是说一个类只能有一个父类，子类可以拥有父类的protected和public修饰的成员属性和方法，但是父类中的private修饰的属性和方法对子类是不可见的。就像日常生活中，你可以使用老爸的一些东西，但是老爸有些东西你是不知道的，他不能让你知道的，因为每个人都有自己的私人空间。当子类中的方法和父类一样时，子类在调用该方法时，运行的是子类自己的方法体。这就是常说的方法的重写。
说到了重写，经常一起说的是方法的重载。方法的重载是指，在一个类中，一个方法有多种形式。这些形式之间的参数类型，参数个数，参数顺序至少有一个不同，在这些基础上还可以是返回值类型不同，这种现象就称为方法的重载。
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.intrduction();
//这三个方法根据需要随意调用哪个方法
son.playSport();
son.playSport("篮球");
son.playSport("篮球",2);
}
}
class Father{
private String name = "Father";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void intrduction(){
System.out.println("嗨,我的名字是"+name);
}
}
class Son extends Father{
private String name ="Son";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 方法的重写
*/
@Override
public void intrduction() {
System.out.println("哈罗,我的名字是"+name);
}
/**
* 方法的重载,必须在参数不一样的情况下才可以让返回值不一样
*/
public void playSport() {
System.out.println("我做运动");
}
public void playSport(String type) {
System.out.println("我做"+type+"运动");
}
public void playSport(String type,int hour){
System.out.println("我做"+type+"运动"+hour+"小时");
}
}一个类的初始化过程：首先会对父类进行初始化,在类的构造方法的第一行,如果没有明确指定调用哪个父类初始化的方法时,会隐藏有一个super()语句,调用的是父类的无参构造方法，如果父类没有无参构造方法，而子类的构造方法有没有调用父类的有参构造方法,那么就会报错,无法通过编译。如果该类没有明确的父类，那么该类的父类就是Object。静态变量先于类而存在，所以类在初始化时,第一个初始化的是类中的静态成员变量，然后是静态代码块,然后是代码块,然后才是构造方法。
所以一个子类的初始化过程是：
1.父类静态成员初始化
2.父类静态代码块初始化
3.子类静态成员初始化
4.子类静态代码块初始化
5.父类代码块初始化
6.父类构造方法初始化
7.子类代码块初始化
8.子类构造方法初始化
public class Test{
public static void main(String[] args) {
Son son = new Son(2);
/**
*这里可以看到控制台打印的是son print.....2,验证了之前的子类重写父类方法,那么子类在调用方法时,会执行的
*是子类中的方法,因为在子类中已经找到了该方法,所以不会再往上找了。
*/
son.print();
Father father = new Son(3);
father.print();
}
}
class Father{
//父类属性初始化
private int num = 6;
public Father() {
System.out.println("Father构造方法........."+num);
}
/**
* 静态代码块,先于类存在
*/
static{
System.out.println("father静态初始化.....");
}
/**
* 初始化代码块
*/
{
System.out.println("father初始化块....."+num);
}
public void print(){
System.out.println("Father print........."+num);
}
}
class Son extends Father{
//本类成员初始化
private static int num;
public Son(int num) {
/**
* 这里隐藏了一个语句super(),子类在初始化的时候,必须要调用父类的构造方法,因为父类先于子类存在,没有老爸哪有儿子。
* 如果父类没有无参构造方法,那么必须调用其中的一个构造方法
*/
super();
System.out.println("Son构造方法");
// 使用this的话不太妥当,因为静态成员先于类存在,而this代表的正是本类
// this.num = num;
Son.num = num;
}
/**
* 静态代码块,先于类存在
*/
static{
System.out.println("son静态初始化....."+num);
num = 9;
}
/**
* 初始化代码块
*/
{
System.out.println("son初始化块....."+num);
}
@Override
public void print(){
System.out.println("son print....."+num);
}
}
对于多态：多态就是一个对象多种形态,在代码中的体现就是父类的引用指向子类对象。Father father = new Son();在这个引用调用方法的时候，如果该方法是重写的方法，那么使用的是子类的方法体。在这里我说一下我的理解，为什么调用的是子类的方法体。在类的一个方法中,如果该方法的局部变量和类的成员变量重名了，那么我们会在类的成员变量前加上this.来加以区分。因为编译器会默认是局部变量，假如不加以区分的话。变量和方法的归类的时候,总是基于一种就近原则，就是从它所在的地方向上一直寻找，直到找打明确的宿主。比如说一个方法有一个变量是name，那么它会先在该方法中寻找是否定义有name这个变量，如果有那么停止寻找，将name归属于该方法中的name,如果该方法中没有找到name这个变量的定义,那么编译器会到类成员变量中寻找，如果找到，将该变量归为成员变量。如果该类中没有继续向上，到达父类。在父类的成员public和protected中寻找，如果没找到就报错。若要加以区分则this.表示的是本类成员，super.表示的是父类的成员
成员变量和局部变量的区别:
1.成员变量定义作用域是整个类,用来给类对象初始化属性。成员变量随着类对象的消亡而消失。
局部变量作用于是方法内部,当方法调用结束,变量就不存在了。
2.当成员变量和局部变量同名时,需要用this关键字区分,this.变量名表示的是成员变量。在方法内部，如果不加this区分
编译器会首先使用的是局部变量,如果方法内部没有该变量,再往上一级(类成员变量中)找。
3.成员变量有默认初始化,而局部变量没有默认初始化
---抽象类
抽象类是指不具体的类，是对一些事物共有的属性的一种封装。比如说Animal类，动物这个类是不具体的，因为动物有非常多的类别。
抽象类的关键词：abstract
抽象类不能实例化，因为它是不具体的，只有抽象类的子类才可以被实例化。这就是父类的引用指向子类对象的一种使用。
abstract class Animal{
public void describe() {
System.out.println("有生命的物体");
}
public abstract void voice() ;
}
class Dog extends Animal{
@Override
public void voice() {
System.out.println("汪汪");
}
}
public class Test{
public static void main(String[] args) {
Dog dog = new Dog();
dog.describe();
dog.voice();
}
}抽象类中可以包含抽象方法和非抽象方法，抽象方法的子类必须覆盖抽象类的所有抽象方法。抽象方法是指没有方法体的方法,抽象方法的定义public abstract void voice() ;
---接口
接口是一种特殊的抽象类，接口的关键字是interface，接口中只能包含抽象方法。接口的实现类使用关键字implements，接口通常用来监听某些事件是用来传递数据，从而达到更新界面的操作
接口的定义和它的实现类:public interface OnClickListener{
public abstract void click(String content);
}
//接口的实现类
class TextClickListener implements OnClickListener{
@Override
public void click(String content) {
}
}接口的使用步骤：
1.定义一个接口
2.在要使用接口传递数据的地方，定义一个接口的引用对象，并且提供set接口方法
3.在要触发传递数据的地方调用接口对应的方法，在这里应该做一个判空的操作
4.在接口点实现这个接口,然后就可以在实现的方法中操作传递过来的数据了
/**
* 定义一个接口
*
*/
public interface OnClickListener{
public abstract void onClick(String content);
}
/**
*
*接口交互类，用来测试触发接口操作
*/
class Caculate{
//定义一个接口的引用
private OnClickListener onClickListener;
//提供set接口方法
public void setOnClickListener(OnClickListener onClickListener){
this.onClickListener = onClickListener;
}
public void autoAdd() {
int i=0;
while(true){
i=i+1;
//i为9时触发接口操作，传递数据
if(i==9){
if(onClickListener != null){
onClickListener.onClick("自增多次后i的值为"+i);
}
break;
}
}
}
}
public class Test implements OnClickListener{
public static void main(String[] args) {
Caculate caculate = new Caculate();
caculate.setOnClickListener(new Test());
caculate.autoAdd();
}
/**
* 在该方法中操作传递过来的数据
*/
@Override
public void onClick(String content) {
System.out.println("传递过来的内容是"+content);
}
}运行结果：
可以看到数据真的传递过来了。这就是接口的简单使用了。
一个类只能继承自一个父类，但是可以实现多个接口。简记就是Java的一个类是单继承，多实现。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
