java基础语法-package构造方法-继承-多态

java中的包 - package

包:包中有很多的类，根据类的功能不同，我们可以创建不同的包。

包的主要功能：

包的主要功能：用于分类管理

包的基本语法

package 包的路径（完整路径，从第一个包开始写路径）
路径与路径之间使用点隔开: package.fatherlujing.sonlujing

在一个文件中，可以没有包，或者一个包。但是不能出现两个包。

包名一般小写，是为了区分类名，类名一般大写

java中存在不同包相同类的名称，我们可以使用包名进行区分

一般情况下，在使用类的情况下，我们都使用类的全类名(包名+类)

全类名

在使用类的时候必须使用类的全类名。否者就容易造成歧义。
有的小伙伴可能会说：
String name='zhangsan'
这里我怎么没有使用全类名呢？
java.lang.String name='zhangsann'  [全类名]
其实这是因为java虚拟机帮我们做了一层处理。自动帮我们添加。所以我们不需要写
记住【只要是java.lang下的类都不需要我们写，虚拟机会帮我们搞定】

new fatherlujing.类名()
new 类名()
上面这两者在同一个目录下是等价的

如何我们想要new一个日期。按照我们刚刚的说法是下面这样写的
java.util.Date d = new java.util.Date();
但是这样写太麻烦了。
此时我们的important就出现了
import java.util.Date; // 导入这个包
Date d = new Date();
这样就不会出问题了。

有些时候可能我们需要导入很多包。如下：
import java.util.a;
import java.util.b;
import java.util.c;
....可能还有很多....
这个时候我们可以使用通配符 * 来解决导出的包太多的问题
import java.util.*;
会自动导入 java.util下的包

【注意】 imporant 不能放在包的前面。
如何使用了不同包相同名称的类，还是需要通过imporant 引入

构造方法：专门用于构建对象

如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象调用。

public class study01 {
	public static void main(String[] args) {
    //	构造方法，专门用于构建对象
    // 如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象调用。
		User user1 =  new User();
	}
}

class User {
	void test(){
		System.out.println("测试方法");
	}
}

上面这个类中没有任何的构造方法。
那么JVM会自动添加一个公共的，无参的构造方法，方便对象调用。

构造方法

1.构造方法的基本语法： 类名(){}
2.构造方法也是方法，只是没有void关键字
3.构造方法名和类名完全相同。
4.如果类中没有构造方法，那么JVM虚拟机会提供默认的构造方法
5.如果类中有构造方法，那么JVM虚拟机不会提供默认的构造方法
6.构造方法也是方法,所以也可以传递参数，但是一般传递参数的目的是用于对象属性赋值。
7.在new的时候构造方法会被执行
8.代码块是在构造方法(创建对象)执行前执行

构造方法会在new的时候被执行

public class study01 {
	public static void main(String[] args) {
    //	构造方法，专门用于构建对象
		User user1 =  new User();
	}
}
class User {
  //	构造方法在new的时候被执行
	User() {
		System.out.println("我是构造方法");
	}
	void test(){
		System.out.println("测试方法");
	}
}

控制台会输出：我是构造方法

构造方法传参一般用于对象属性赋值

public class study01 {
	public static void main(String[] args) {
    //	构造方法，专门用于构建对象
		User user1 =  new User("张三", 10);
		System.out.println("useName的属性值"+ user1.useName);
	}
}
class User {
	// 属性
	String useName;
	int useAge;
  //	构造方法在new的时候被执行
	User(String name, int age) {
   //		对象属性赋值
		useName = name;
		useAge = age;
		System.out.println("我是构造方法"+ "我叫:"+ useName + ";今年:"+useAge);
	}
}
在控制台会输出：
我是构造方法我叫:张三;今年:10
useName的属性值张三

代码块是在构造方法执行前执行

public class study01 {
	public static void main(String[] args) {
    //	构造方法，专门用于构建对象
    //	如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象调用。
		User user1 =  new User("张三", 10);
	}
}

class User {
	//下面是对象的属性
	String useName;
	int useAge;
  //	构造方法在new的时候被执行
	User(String name, int age) {
    //对象属性赋值
		useName = name;
		useAge = age;
		System.out.println("我是构造方法"+ "我叫:"+ useName + ";今年:"+useAge);
	}
  {
		System.out.println("我是代码块,我在创建对象之前执行");
	}
}
在控制台依次输出：
我是代码块,我在创建对象之前执行
我是构造方法我叫:张三;今年:10

继承

1.类存在父子关系：子类可以直接获取到父类的成员属性和成员方法。
2.类的继承只能是单继承。一个类只能有一个父类，不能存在多个父类；
  就是说你能既继承了A类，又继承了B类。
3.一个父类可以有多个子类
4.继承的基本语法： 子类 extends 父类

继承的简单应用，子类什么都没有写，直接调用父类中的方法

public class study01 {
	public static void main(String[] args) {
     Son son1 = new Son();
     //     调用父类中的方法。
     son1.say();

	}
}
//父类
class Father{
	String name;
	void say(){
		System.out.println("我是说话了");
	}

}
//子类继承父类
class Son extends Father{

}
控制台直接输出:我是说话了

如果父类和子类含有相同的属性，那么可以采用特殊的关键字进行区分 usper this

usper this 这两个关键字在静态方法和静态代码块中是不能使用的

父类和子类含有相同的属性

public class study01 {
	public static void main(String[] args) {
     Son son1 = new Son();
     //     调用父类中的方法。
     son1.test();

	}
}

//父类
class Father{
  //	这里有一个name属性
	String name="张三";
	void say(){
		System.out.println("我是说话了");
	}
}
//子类继承父类
class Son extends Father{
   //	这里也有一个name属性
	String name="李四";
	void test(){
		System.out.println("我是说话了"+name);
		System.out.println("我是说话了"+name);
	}
}  

控制台输出的是：
我是说话了李四
我是说话了李四
ps:现在我们想区分子类中的name和父类中的name.

如何区分父类和子类中相同的属性

public class study01 {
	public static void main(String[] args) {
    Son son1 = new Son();
    // 调用父类中的方法。
    son1.test();
	}
}
//父类
class Father{
  //	这里有一个name属性
	String name="张三";
	void say(){
		System.out.println("我是说话了");
	}
}
//子类继承父类
class Son extends Father{
  //	这里也有一个name属性
	String name="李四";
	void test(){
		System.out.println("我是说话了"+this.name);
		System.out.println("我是说话了"+super.name);
	}
}
控制台输出的是：
我是说话了李四
我是说话了张三

构建了多少个父类对象

1.父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建。

2.默认情况下，子类对象构建时，会默认调用父类的构造方法完成父类对象的构建，使用的是super的方式进行，只不过JVM自动完成的。

3.如果父类提供了构造方法，那么JVM不会提供默认的构造方法，此时子类应该显示调用super方法构建父类对象

构建了多少个父类对象

public class study01 {
	public static void main(String[] args) {
     // 请问构建了多少个父类对象
     Son son1 = new Son();
     Son son2 = new Son();
     Son son3 = new Son();
	}
}
//父类
class Father{
	void say(){
		System.out.println("我是说话了");
	}
}
//子类继承父类
class Son extends Father{

}

有的小伙伴可能会说：1个，有的小伙伴可能会说3个。
1个原因：虽然构建了3个子类对象，但是继承的是同一个父类对象。所以是1个。
3个原因：我构造了3个子类对象，所以有3个父类对象。

通过构造方法查看构造了多少个父类对象

public class study01 {
	public static void main(String[] args) {
     Son son1 = new Son();
     Son son2 = new Son();
     Son son3 = new Son();
	}
}

//父类
class Father{
	Father(){
		System.out.println("构造方法");
	}
}
//子类继承父类
class Son extends Father{

}
在控制台输出了3次。
说明确实是构造了 3个父类对象

父类提供了构造方法,此时子类应该显示调用super方法构建父类对象

public class study01 {
	public static void main(String[] args) {
     Son son1 = new Son();
	}
}

//父类
class Father{
	String userName;
	// 父类提供了构造方法
	Father(String name){
		userName = name;
		System.out.println("构造方法" + userName);
	}
}
//子类继承父类
class Son extends Father {
	Son(){
//  如果父类提供了构造方法，那么JVM不会提供默认的构造方法，此时子类应该显示调用super方法构建父类对象
	  super("张三");
	}
}

new只会构建一个对象

new只会构建一个对象。在内存在开辟了1个空间来存储创建出来的对象。
也就是:你不能说写了2个new,构建了2个对象。
Son son1 = new Son();
Son son2 = new Son();
你这不对呀？ 跟刚刚说的不一样的。

多态

所谓的多态:其实就是一个对象在不同的场景下表现出来的不同状态和形态。
多态语法其实就是对对象的使用场景进行约束
一个对象可以使用的功能取决于引用变量的类型

public class study01 {
	public static void main(String[] args) {
		Person p1 = new Person();
		Person p2 = new Body();
		Person p3 = new Girl();
	}
}

class Person{
}
class Body extends Person {
}
class Girl extends Person {
}

多态的一个表现

public class study01 {
	public static void main(String[] args) {
		Person p1 = new Person();
		Person p2 = new Body();
        // p2.testBody(); // 会报错
		p2.testPerson(); // 正常的
		Person p3 = new Girl();
	}
}

class Person{
	void testPerson(){
		System.out.println("testPerson");
	}
}

class Body extends Person {
	void testBody(){
		System.out.println("testBody");
	}
}
class Girl extends Person {
	void testGirl(){
		System.out.println("testGirl");
	}
}

多态的一个表现

子类类型赋值给父类  Father f1 = New Son(),
调用子类方法报错。 调用父类方法OK。这个就是多态