前言

Java基础-类与对象，方法的重载，构造方法的重载，static关键字，main()方法，this关键字，包，访问权限，类的继承，继承性，方法的重写，super变量。

方法的重载：成员方法的重载和构造方法的重载

方法的重载

在一个类中可以有多个方法具有相同的名字，但是这些方法的参数个数不同，或参数类型不同，即为方法的重载。

class Demo{

 // one

 void dashu(String name){

  System.out.println(name);

 }

 // two

 void dashu(String name,String score){

  System.out.println(name+score);

 }

 // three

 void dashu(String name,String score,Int age){

  System.out.println(name+score+age);

 }

  public static void main(String[] args){

   Demo demo = new Demo();

   demo.dashu("dashucoding");

   demo.dashu("dashucoding","一百");

   demo.dashu("dashucoding","一百",10);

  }

}

构造方法的重载

class Person{

 String name;

 int age;

 float height;

 float weight;

 // 构造方法

 public Person(){

  age = 13;

  name="dashu"

 }

 public Person(String name){

  this.name = name;

 }

 // 构造方法的重载

 public Person(String name, int age){

  this.name = name;

  this.age = age;

 }

 void print(){

  System.out.println(name+age);

 }

}

class Test{

 public static void main(String[] args){

  Demo demo1,demo2,demo3;

  demo1 = new Demo();

  demo2 = new Demo("dashu");

  demo3 = new Demo("dashu",12);

  demo1.print();

  demo2.print();

  demo3.print();

 }

}

static关键字

被static修饰的变量为静态变量

被static修饰的方法为静态方法

静态变量属于类而不属于类的某个实例，可被直接类名调用，所以叫类变量

静态方法属于类而不属于类的某个实例，可被直接类名调用，所以叫类方法

非静态的成员变量和方法，必须通过实例化后通过对象名来调用

所以叫实例变量和实例方法

实例变量和实例方法通过实例调用，类变量和类方法同样也可以通过实例调用

这点要注意

---

main()方法

main()方法为静态的，在java虚拟机中执行main()方法时不需要创建main()方法所在类的实例就可调用，因为有static修饰。

例子

class Demo{

 // 定义静态的成员变量

 static int x;

 int y;

 // 定义静态的成员方法，用来获取值

 public static int getX(){

  return x;

 }

 // 定义静态的成员方法，用来设置值

 public static void setX(int newX){

   x = newX;

  }

 public int getY(){

  return y;

 }

 public void setY(int newY){

  y = newY;

 }

}

静态方法可以调用同类的静态成员，不能调用非静态成员，反之能；静态成员可通过类名调用，也可通过实例对象，静态方法中不能使用this和super。

this关键字

this代表使用该方法的当前的对象，只用于实例方法或者构造方法中。

void setAge(int age){

 this.age = age;

}

Person(String name, int age){

 this.name = name;

 this.age = age;

}

---

包

在java中提供了不同的类和接口存放在不同的包中。

常见的包

java.applet

java.awt

java.net

java.util

java.lang

java.io

包的格式：

package 包名[.子包名[…]];

引入java包

import  包层次结构的类名;

访问权限

修饰符：

public、private、protected、友好

private变量和方法

访问权限最小，只能在同一个类中被访问，私有成员可以被对象实例调用，方法被对象实例调用，静态成员可以被类名直接调用。

class Demo{

 private static String name;

 private int age;

 private void print(){

  System.out.println(name+age);

 }

 public static void main(String[] args){

 Demo.name = "dashu";

 Demo d = new Demo();

 d.age = 12;

 d.print();

 }

}

private，类中的私有变量不能被另一个类所引用，私有变量和方法只能在本类中使用。

class Demo{

 private static String name;

 private int age;

 private void print(){

  System.out.println(name+age);

 }

 public static void main(String[] args){

 Demo.name = "dashu";

 Demo d = new Demo();

 d.age = 12;

 d.print();

 }

}

// 另一类

class Da{

 public static void main(String[] args){

  // 非法使用

 Demo.name = "dashu";

 // 非法调用

 Demo d = new Demo();

 d.print();

 }

}

public 访问修饰符，它的访问权限在不同类，不同包的类中访问

默认，友好权限只能被同类或同包中的不同类引用

protected不能在不同包中的类所引用

访问权限	public	protected	友好	private
同类	可以	可以	可以	可以
同包不同类	可以	可以	可以
不同包子类	可以	可以
通用	可以

---

类的继承

在java中可以单继承，不支持多继承，一个子类只能有一个父类，不能有多个，但一个父类可以有多个派生的子类。

public class Person{

     String name;

     int age;

     public void setAge(int age) {

	this.age=age;

     }

     public void out()   {

     	System.out.println("姓名:"+name+" 年龄:"+age+"岁");

     }

}

// 子类继承父类

public class Student extends Person{

 ...

}

继承性

子类继承父类，可以继承父类中非私有成员（子类和父类在同一包中），如果不在同一包中，子类只能继承父类中受保护的和公有的成员。

方法的重写

方法的重写，子类覆盖父类的方法，定义了与父类相同名，相同类型，并且相同参数的方法。

super变量

super，提供了对父类的访问，可以访问父类被子类的隐藏的变量和覆盖的方法。

结语

• 本文主要讲解 Java基础-类与对象
• 下面我将继续对Java、 Android中的其他知识 深入讲解 ，有兴趣可以继续关注
• 小礼物走一走 or 点赞