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");
}
}