前言
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 点赞
