Java作为一种面向对象语言。支持以下基本概念：

  • 多态
  • 继承
  • 封装
  • 抽象
  • 类
  • 对象
  • 实例
  • 方法
  • 重载

成员变量包括：实例变量、类变量

成员方法包括：实例方法、类方法、构造方法

基本数据类型包括：byte、short、int、long、float、double、boolean、char

指针问题：不能说Java没有指针，它只是没有显示指针。对象引用实际上就是指针

Java中工程（项目）、包、类区别

  1. 项目就是project，包就是package，而class就是类了，项目里面包括所有的包，包是用来便于管理类，防止命名冲突，类是代码的容器，它们的关系就是上级与下级的关系，项目的下一级就是包，包的下级就是类
  2. 工程相当于一个软件，包相当于模块，类相当于模块下各个功能的实现
  3. 类下再有各种自己具体完成任务需要的成员变量和实现方法。主方法也在某一个public类中
  4. 包(package)相当于姓名中的“姓”，类(class)相当于“名”。所以在调用某类方法的时候，不仅需要指明方法所在的“名”，即类，还要指明方法类所在的“姓”，即类。这样编译器才知道你调用的方法是哪一个。

  5. 包类具体使用：
    mark

  6. 注意：

    • 类名和文件名相同，一个Java文件中最好仅定义一个类，多类不方便管理。
    • 如果多类定义，则仅有一个类可以被public修饰，这个类且必须和文件同名，其他类则不能被其他包里类所引用。此外，若存在主方法main函数，public的main方法只能存放在这个public类当中。
    • 由于main方法是静态的，所以不可以直接调用类中非静态成员变量或方法。但是可以在main函数中创建实体（对象）再调用方法和变量。(即用new)
    • 包建议小写字母开头，而类以大写字母开头。

问题

  • 包用来解决什么问题？

    • 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用
    • 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
    • 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类

  • java.awt.*是什么

    • java.awt包，即java抽象窗口工具包（Abstract Window Toolkit,AWT)提供了许多用来设计GUI（Graphics User Interface,图形用户界面）组件类。

友好变量、友好方法、友好类

  • 友好变量、友好方法
    • 所谓友好即 不被public、protected、private关键修饰的变量和方法区别在于 比public低一级，用于只能在同一包下访问的变量

Java一共有四种权限，private (私有)，public（公有）。Protected（受保护）还有友好型。这些语句都可以修饰类中的成员变量和方法，但是只有public和友好型可以修饰类。

mark

类、实例、对象区别

  • 类是对一项事物的抽象概括，是一个模板，可以包含该事物的一些属性定义，以及操作属性的方法
  • 实例简单理解，就是new，就是对类的实例化，创建这个类对应的实际对象，类只是对事物的描述，而实例化就相当于为这个描述新开辟了一块内存，可以改变这块区域里的各种属性（成员变量），当然，也可以实例化多块区域，只是不同的对象而已。
  • 类跟对象mark
  • 可以这么说，对象就是实例，new的过程就是对象实例化的过程
    • 例：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      //ps就是对象的一个**引用**，要对这个对象进行操作的时候，就可以通过这个引用
      public class Peason 
      { 
      String name; 
      String sex; 
      int age; 
      public static void main(String [] args) 
      { 
      Peason ps=new Peason(); 
      ps.name=”张三”; 
      ps.sex=”男”; 
      ps.age=10; 
      } 
      }

构造方法（即构造函数）

  1. 是一种特殊的方法，它是一个与类同名且没有返回值类型的方法
  2. 对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化
  3. 满足如下语法规则：
    1. 方法名与类名相同
    2. 不要声明返回类型
    3. 不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承，所以用final和abstract修饰没有意义
    4. 不能使用return语句来返回一个值
  4. mark

  5. 例子：一个类可以有多个构造方法！

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //以下Sample类中，具有int返回类型的Sample(int x)方法只是个普通的实例方法，不能作为构造方法
    public class Sample {
    private int x;
          public Sample() { // 不带参数的构造方法
          this(1);
          }
      
          public Sample(int x) { //带参数的构造方法
          this.x=x;
      	}
      
      	public int Sample(int x) { //不是构造方法
      	return x++;
      	}
      
      	}

  6. 如果构造函数的部分行为与已有的构造函数相同，可以在该构造函数中调用已有的构造函数。
    例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //第二个构造函数只接受x和y的坐标作为参数，由于没有定义半径，
    //因此使用默认值1——调用第一个构造函数，并将xPoint、yPoint、1作为参数传递给它
    	class Circle{
    	int x,y,radius;
    	
    	Circle(int xPoint,int yPoint,int rediusLength){
    		this.x=xPoint;
    		this.y=yPoint;
    		this.radius=rediusLength;
    	}
    	
    	Circle(int xPoint,int yPoint){
    		this(xPoint,yPoint,1);
    	}
    }

注意：

  • 构造方法可以重载，以参数的数目，类型，顺序
  • 如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
  • 构造方法不能被继承：
    • 子类只继承父类的默认(缺省)构造函数（即无形参构造函数），如果父类没有默认构造函数，那子类不能从父类继承默认构造函数。
    • 子类从父类处继承来的父类默认构造函数，不能成为子类的默认构造函数。
    • 在创建对象时，先调用父类默认构造函数对对象进行初始化，然后调用子类自身自己定义的构造函数。
    • 如果子类想调用父类的非默认构造函数，则必须使用super来实现

内存管理

不同于其他面向对象语言，Java在内存管理是动态的、自动的，当你创建对象时，Java自动分配相应的内存，当使用完对象后，Java虚拟机自动查找未用的对象并回收这些对象占用的内存

权限问题

mark

Java类的访问控制

mark

Java中不同控制符对应的权限

java中的访问修饰符讲解

mark

实例变量与类变量的区别，实例方法和类方法的区别

详细链接一
详细链接二

  1. 类变量：静态域，静态字段，或叫静态变量，它属于该类所有实例共有的属性，在内存中只有一个地方存储这个变量
  • 类变量、类方法就是类中的变量、方法，必须是静态的，要加static；故其又称静态变量、静态方法。
  • 实例变量：实例域，实例字段，或叫成员变量。
  • 实例方法：或叫成员方法，必须先有实例，然后才能通过实例调用该实例方法
  • 类变量和实例变量都必须在方法和语句块之外，区别在于类变量static而实例变量不是，类方法和实例方法的区别也是在有没有static上
  • 类方法是属于整个类，而不属于某个对象
  • 类方法的调用可以通过类名.类方法和对象.类方法，而实例方法只能通过对象.实例方法访问
  • 类方法只能访问类方法，而实例方法可以访问类方法和实例方法。
  • 类方法不能被覆盖，实例方法可以被覆盖（待验证）
  • 每个实例都将有一个实例变量的一个副本，他们可以修改实例变量的值，而不会影响其他的示例；类变量只有一个副本，修改它的值将影响所有的实例
  • 类方法与类变量一样，适用于整个类，而不是某个实例。类方法通常用作通用的工具方法，然不是直接操作某个对象，而是整个类。
  • 类方法还可以用来将通用的方法集中起来，放在一个地方（即类中）。例如：在java.lang包中定义的类Math,将大量的数学运算作为类方法。不能创建Math对象，但可以只用它的类方法，并将数字和布尔值作为参数
  • 使用方法：
    • 类方法可以直接调用类变量和类方法
    • 类方法不可以直接调用实例变量和实例方法
    • 类方法中没有this，因为没有实例，this不知道调用哪个实例(只能在实力方法的定义体内使用this)，super也不行
    • 类方法可以从类里面直接访问类成员
    • 实例方法可以调用类方法，访问类变量，但是不提倡这样做，会把类方法和类变量混淆成实例方法和实例变量

例子：

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
	package Mypackage;

	class AnIntegerNamedX {
	 static int x; 
	// 这里写成static，结果就变成全是2了，因为类变量是被实例所共享的，
	//包括myX和anotherX调用anotherX时所有的实例都改变了。

	public int x() {
	
	return x;
	}

	public void setX(int newX) {
	x = newX;
	}
}

public class Practice {
public static void main(String args[]) {
	AnIntegerNamedX myX = new AnIntegerNamedX();
	AnIntegerNamedX anotherX = new AnIntegerNamedX();

	myX.setX(1);
	anotherX.x = 2; // 这里把X的值改成2，所有实例的X都是2了，因为类变量是被
	//所有实例共享的，任何实例都可以对类变量做最终的修改

	System.out.println("myX.x = " + myX.x());
	System.out.println("anotherX.x = " + anotherX.x());

}
}

结果为：

mark

若将static int x;改成int x;，则结果为：

mark

若将static int x;改成int x;，将x()方法和setX()加上static变成静态方法，则会提示错误让把X变成静态，是因为类方法不能直接访问实例变量！