第一周预习博客

第一周预习博客

一.面向对象的三大特性

1.1.类和对象（封装性）

面向对象编程的核心思想之一就是将数据和对数据的操作封装在一起。

类：将共性集合在一起给出一个抽象概念;例如"机动车类”

当需要给出类的一个具体的实例的时候，自然而然地就有了一个具体实例的概念，即对象；

类是一类对象的模板，对象是类的一个实体，例如：学生小红。

在抽象一个类的时候，需要给出他静态和动态的，反映到JAVA里的时候，就是成员变量（属性）和方法，对象之间区分的时候靠的就是属性的不同，即成员变量的取值不同；

类和类或对象与对象之间有关系，就相当于任何人之间的关系：关联，聚合，继承，实现

只有定义了类，才会有对象。

对象是静态和动态属性的封装体，即函数和成员的封装体。

下面这段伪代码基于我对类与对象的理解而写

class cat{       //定义了一个类
  char furcolor;  //定义成员变量
  float hight; //定义成员变量
  void catchmice(char m) {
  //}//定义方法（函数），省去了函数的执行步骤
}


public static void main(String[] args){
cat a = new cat();  //造出一个世纪对象a,是cat类
mice m = new mice(); //造出一个对象
a.catchmice(m) //行为实现，即方法实现
}

1.2.继承性（子类和继承）

例如：狗可以跑，猫可以跑，那么就可以定义一个“跑”在动物类里，通过某种方法让猫，狗或者其他会跑的动物对象来继承跑这个动作，即猫，狗这些”子类“继承了“动物”这个基类（父类），当继承完成后，子类自动拥有了父类的全部成员，包括成员变量和方法，所以说继承相当于代码的重复使用。

注意，一个子类只能有一个父类（一个儿子只能有一个爸爸）；但一个父类可以派生出多个子类（一个爸爸可以有多个儿子）

例如下面这段代码：

class Animal {
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Dog {
    public void eat() {
        System.out.println(this.name+"吃东西");
    }
}
class Bird {
    public void eat() {
        System.out.println(this.name+"吃东西");
    }
    
    public void fly() {
        System.out.println(this.name+"起飞");
    }
}

这个代码存在多余代码.
仔细分析, 我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系。
这三个类都有相同的eat方法
此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 减少代码冗杂度；

---

1.2.1.extends实现继承

具体形式：

class 子类 extends 父类 {
}

对于上面的代码，可以写成这种形式：

class Animal {
    public void eat() {
        System.out.println(this.name + " 正在吃");
    }
}

class Dog extends Animal {
}

class Bird extends Animal{
    public void fly() {
        System.out.println(this.name+"起飞");
    }
}

其中Dog和Bird的eat方法继承了Animals，简化了代码；

---

在子类继承父类的方法时候，可以通过重写来隐藏已经继承的方法

class University{
    void enter(double math , double english, double Chinese){
        double sum = math + english + Chinese;
        if(sum >= 180)
            System.out.println("录取");
        else
            System.out.println("未录取");
    }
}


class  imUniversity extends University{
    void enter(double math , double english, double Chinese){ //重写的时候变量的类型一定要保持一致！！
        double sum = math + english + Chinese;
        if(sum >= 150)  //隐藏并重写父类enter方法中的录取线，
            System.out.println("录取");
        else
            System.out.println("未 录取");
    }
}

public class cly extends imUniversity{
    public static void main(String args[]){
        imUniversity univer=new imUniversity();
        univer.enter (50.7,78.3,98.5);
   }
}

---

1.2.2.访问权限关键字

	private	defult	protected	public
同一个类	√	√	√	√
同一个包内的类	×	√	√	√
不同包内的子类（包含继承）	×	×	√	√
不同包内的非子类	×	×	×	√

格式

private/protected/ipublic int a；（defult可省略不写）

---

1.2.3.super关键字

super代表父类的引用，用于访问父类的属性，方法，构造器。

super注意事项：
1.访问父类的属性和方法时，不能访问父类的private属性和方法。
2.访问父类的构造器，super(参数列表);只能放在构造器的第一句，只能出现一句。

---

下面是super使用的一个实例：

class student{
    int number;
    String name;
    void Student(int number,String name){
        System.out.println("My name is"+name+". my Student number"+number+".");
    }
}

class University extends student{
    boolean marry;
    University(int number,String name,boolean b) {
        super.Student(number,name);
        marry = b;
        System.out.println(marry);
    }
}

public class cly {
    public static void main(String args[]) {
        University zhang = new University(9901,"cly",false);
    }
}

前两个学号和姓名的方法不用在子类里面定义了，直接使用super用父类的，boolean是子类里面新定义的，这就是super的作用。

---

1.2.4.final关键字

1.final修饰变量，相当于定义常量，这个常量不能再被修改
2.final修饰类，密封类：当前类不能再继承
3.final修饰方法，密封方法：该方法不能进行重写

---

1.3.多态

多态其实就是一种思想，一个事物表现出不同的形态，就是多态。

1.3.1.向上转型（子类对象转化成父类对象）

java
class C{
    void bug(){
    }
}

class JAVA extends C{
   void bug(){
       System.out.println("a cup of tea");
   }
}

class python extends C{
  void bug(){
      System.out.println("A pack of cigarettes");
    }
}

class js extends C{
    void bug(){
        System.out.println("Change a bug to another day");
    }
}

public class cly {
    public static void main(String args[]) {
       C programmer;  
       programmer = new JAVA();  //父类
       programmer.bug();
       programmer = new python();
       programmer.bug();
       programmer = new js();
       programmer.bug();
    }
}

1.3.2.向下转型（父类对象转成子类对象）

class Animals{
    public void eat(){
    }
}

class Dog extends Animals{
    public void eat(){
        System.out.println("dogs are eaing");
    }
}

public class cly{
    public static void main(String args[]) {
        Animals a = new Dog();
        a.eat();
        Dog b = (Dog)a;  //强制父类转换子类
        b.eat();
    }
}

---

1.4.总结

1.封装：提高代码的安全性。
2.继承：为了代码的复用，提高效率（单向继承）。
3.多态：一个事物表现出不同的形态。

---

二.配环境（主要关于JAVA）

关于配环境的问题主要是一些JAVA底层的原理

2.1.为什么要装虚拟机？

Java通过虚拟机（Java Virtual Machine，称为JVM）可以在不同的操作系统上运行Java程序，相当于屏蔽了底层的操作系体，在自己所创造的虚拟环境中运行，不会因为操作系统影响代码运行。

---

2.2.什么是jdk，jre？

JDK：JAVA Development kit，软件开发包
JRE：JAVA Runtime Environment，JAVA运行环境

开发需要jdk，用户只需要jre

---

2.3.jdk文件

sample：例子程序
demo：演示程序
bin：二进制，所有编译好可以运行的程序都在bin里面,内有javac.exe，有java.exe文件，即编译文件和运行文件
lib：库文件
jre：运行环境
src：JAVA的源代码

---

2.3.path与classpath环境变量

path：windows系统执行命令时要搜寻的路径
classpath：JAVA在编译和运行是要找的class路径
当系统要执行某个命令的时候，它回去找寻命令所在的路径，即path，去找在路径上的这些目录下有没有可执行的命令，所以要执行JAVA命令只需将bin的路径加到path里。
原程序（*.java）的名字必须是主类的名字