Java学习（1）

发表于 | 分类于 | | 次阅读

前面

学了数据结构后真心感觉C类难用，指针和一些严格的格式要求等，于是决定开始学习Java。前面部分是关于Java的一些控制、循环，数据类型等基础部分几乎和C++相同，记录一下关于面向对象的一些必要知识和概念，和Java面向对象的一些特点。

1.什么是面向对象

大一学习的C类语言，是面向过程语言。简单来说，在我们解决一些问题时，我们是在思考如何解决这个问题过程的基础上编写代码，通过设计算法，调用函数来一步步实现。而面向对象是把问题拆解为一个一个的对象，建立对象，建立对象的目的不是为了完成某个步骤，而是建立解决这个问题的步骤中所使用的方法。

举个例子：

现在你有一笔现金，站在ATM机前，现金要存进卡里，解决这个问题

C类：

(1)我要先把卡插进ATM机(得到ATM机)

(2)然后(在ATM机上)输入密码

(3)然后(在ATM机上)点击’存款’选项

(4)把钱放进ATM机中

(5)然后点击退卡

Java：

(1)ATM.插卡()

(2)ATM.输入(密码)

(3)ATM.点击(存款)

(4)ATM.放进(钱)

(5)ATM.退卡()

2.面向对象（Java）的特性

几乎所有面向对象的程序设计语言都有是三个特性，即封装性，继承性和多态性。

2.1封装性

封装性是面向对象的核心思想。将对象的属性和方法封装起来，然后定义已public的接口来传入参数和获得参数，封装可以使数据得到保护。

(1)属性封装。Java中类的属性设置为private(私有的) 即只可以在类的内部访问。对于这类私有属性，要对其给出一对方法【getxxx()和setxxx()】访问这些私有属性。

(2)方法的封装。和属性封装类似。

2.2继承性

继承性主要是指类与类之间的关系。通过继承，可以增强了代码的复用性，提高了开发效率。

Java中继承要使用extends 关键字，并且一个类只能继承一个父类（也就是单继承）。子类只能继承到在父类中允许访问的属性的方法，但私有属性与方法也被继承了，只是子类无法访问罢了。

2.3多态性

2.3.1静态多态

重载，有相同方法名，但传入的参数列表不同。

很简单，举个例子就明白了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test{//简单方法不带参数了
	void test(){
		System.out.println("No parameters");
	}
//重载上面方法
	void test(int a){
		Ststem.out.println("a:"+a);
	}
 //继续重载
  void test(int a,double b){
    System.out.println("a and b:"+a+" "+b);
	}
 //也可以改变参数类型
  int test(int a){
    System.out.println("a="+a);
    return a+1;
	}
}
public static void main(String args[]){
  Text p=new Test();
  p.test();
  p.test(1);
  p.test(2,2.0);
  p.test(2);
}

然后运行结果为

1
2
3
4
5
6
7
No parameters

a:1

a and b:2 2.0

a=2

注意

  • 方法名称必须相同
  • 方法的参数列表至少有一项不同，参数变量名不同不行
  • 返回值类型和修饰符可相同也可不相同
2.3.2动态多态

概念：

  • 向上转型：父类对象通过（new）子类实例化
  • 向下转型：父类对象强制转换为子类对象

还有3个前提

  • 必须有继承关系
  • 子类要重写父类的方法
  • 父类引用向子类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Animal { //父类Animal
  int age = 10;
  public void eat(){
    System.out.println("动物吃东西");
  }
  public void shout(){
    System.out.println("动物在叫");
  }                 
  public static void run() {
    System.out.println("动物在跑");
  }
}
class Dog extends Animal { //子类Dog继承父类Animal，int age = 60
  String name "黑子";  //子类独有的属性
  public void eat(){
    System.out.printlnl("狗在吃东西");
  }
  public static void run(){
    System. out.println("狗在跑");
  }
  public void watchDoor(){  //子类独有的方法
    System.out.println("狗在看门");
  }
}
public class Test(){
  public static void main(String args[]){
    Animal a1=new Dog();     //父类通过new子类实例化
    al.eat();
    al,shout();
    al.run();
    System.out.println(a1.age);
  }
}

运行结果如下

1
2
3
4
5
6
7
狗在吃东西

动物在叫

动物在奔跑

10

(1)存在继承关系，Dog类继承了Animal类

(2)子类重写父类的方法。子类重写了父类的两个方法 eat()和run()。eat()子类覆盖了父类的eat()方法，其中run()是静态的不做改变。

(3)父类数据类型的引用指向子类对象，即Animal a1 = new Dog。

访问子类中独有的方法和属性

通过向下强制转型实现:

1
2
3
Animal a1 = new Dog;

Dog d1 = (Dog) a1;//强制转换

就可以实现访问子类加入的独有的方法或属性。

Java学习(1)

0%