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

java中的包 - package

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

复制代码

包的主要功能：

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

复制代码

包的基本语法

1. package 包的路径
2. 路径与路径之间使用点隔开: package.fatherlujing.sonlujing

复制代码

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

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

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

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

全类名

1. 在使用类的时候必须使用类的全类名。否者就容易造成歧义。
2. 有的小伙伴可能会说：
3. String name='zhangsan'
4. 这里我怎么没有使用全类名呢？
5. java.lang.String name='zhangsann'  [全类名]
6. 其实这是因为java虚拟机帮我们做了一层处理。自动帮我们添加。所以我们不需要写
7. 记住【只要是java.lang下的类都不需要我们写，虚拟机会帮我们搞定】
9. new fatherlujing.类名()
10. new 类名()
11. 上面这两者在同一个目录下是等价的
14. 如何我们想要new一个日期。按照我们刚刚的说法是下面这样写的
15. java.util.Date d = new java.util.Date();
16. 但是这样写太麻烦了。
17. 此时我们的important就出现了
18. import java.util.Date; // 导入这个包
19. Date d = new Date();
20. 这样就不会出问题了。
22. 有些时候可能我们需要导入很多包。如下：
23. import java.util.a;
24. import java.util.b;
25. import java.util.c;
26. ....可能还有很多....
27. 这个时候我们可以使用通配符 * 来解决导出的包太多的问题
28. import java.util.*;
29. 会自动导入 java.util下的包
32. 【注意】 imporant 不能放在包的前面。
33. 如何使用了不同包相同名称的类，还是需要通过imporant 引入

复制代码

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

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

1. public class study01 {
2.         public static void main(String[] args) {
3.     //        构造方法，专门用于构建对象
4.     // 如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象调用。
5.                 User user1 =  new User();
6.         }
7. }
9. class User {
10.         void test(){
11.                 System.out.println("测试方法");
12.         }
13. }

复制代码

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

复制代码

构造方法

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

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.     //        构造方法，专门用于构建对象
4.                 User user1 =  new User();
5.         }
6. }
7. class User {
8.   //        构造方法在new的时候被执行
9.         User() {
10.                 System.out.println("我是构造方法");
11.         }
12.         void test(){
13.                 System.out.println("测试方法");
14.         }
15. }
17. 控制台会输出：我是构造方法

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.     //        构造方法，专门用于构建对象
4.                 User user1 =  new User("张三", 10);
5.                 System.out.println("useName的属性值"+ user1.useName);
6.         }
7. }
8. class User {
9.         // 属性
10.         String useName;
11.         int useAge;
12.   //        构造方法在new的时候被执行
13.         User(String name, int age) {
14.    //                对象属性赋值
15.                 useName = name;
16.                 useAge = age;
17.                 System.out.println("我是构造方法"+ "我叫:"+ useName + ";今年:"+useAge);
18.         }
19. }
20. 在控制台会输出：
21. 我是构造方法我叫:张三;今年:10
22. useName的属性值张三

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.     //        构造方法，专门用于构建对象
4.     //        如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象调用。
5.                 User user1 =  new User("张三", 10);
6.         }
7. }
9. class User {
10.         //下面是对象的属性
11.         String useName;
12.         int useAge;
13.   //        构造方法在new的时候被执行
14.         User(String name, int age) {
15.     //对象属性赋值
16.                 useName = name;
17.                 useAge = age;
18.                 System.out.println("我是构造方法"+ "我叫:"+ useName + ";今年:"+useAge);
19.         }
20.   {
21.                 System.out.println("我是代码块,我在创建对象之前执行");
22.         }
23. }
24. 在控制台依次输出：
25. 我是代码块,我在创建对象之前执行
26. 我是构造方法我叫:张三;今年:10

复制代码

继承

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

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.      Son son1 = new Son();
4.      //     调用父类中的方法。
5.      son1.say();
6.                
7.         }
8. }
9. //父类
10. class Father{
11.         String name;
12.         void say(){
13.                 System.out.println("我是说话了");
14.         }
15.        
16. }
17. //子类继承父类
18. class Son extends Father{
19.        
20. }
21. 控制台直接输出:我是说话了

复制代码

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

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

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

1. public class study01 {
2.         public static void main(String[] args) {
3.      Son son1 = new Son();
4.      //     调用父类中的方法。
5.      son1.test();
6.                
7.         }
8. }
10. //父类
11. class Father{
12.   //        这里有一个name属性
13.         String name="张三";
14.         void say(){
15.                 System.out.println("我是说话了");
16.         }
17. }
18. //子类继承父类
19. class Son extends Father{
20.    //        这里也有一个name属性
21.         String name="李四";
22.         void test(){
23.                 System.out.println("我是说话了"+name);
24.                 System.out.println("我是说话了"+name);
25.         }
26. }  
28. 控制台输出的是：
29. 我是说话了李四
30. 我是说话了李四
31. ps:现在我们想区分子类中的name和父类中的name.

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.     Son son1 = new Son();
4.     // 调用父类中的方法。
5.     son1.test();
6.         }
7. }
8. //父类
9. class Father{
10.   //        这里有一个name属性
11.         String name="张三";
12.         void say(){
13.                 System.out.println("我是说话了");
14.         }
15. }
16. //子类继承父类
17. class Son extends Father{
18.   //        这里也有一个name属性
19.         String name="李四";
20.         void test(){
21.                 System.out.println("我是说话了"+this.name);
22.                 System.out.println("我是说话了"+super.name);
23.         }
24. }
25. 控制台输出的是：
26. 我是说话了李四
27. 我是说话了张三

复制代码

构建了多少个父类对象

1.父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建。
2.默认情况下，子类对象构建时，会默认调用父类的构造方法完成父类对象的构建，使用的是super的方式进行，只不过JVM自动完成的。
3.如果父类提供了构造方法，那么JVM不会提供默认的构造方法，此时子类应该显示调用super方法构建父类对象
构建了多少个父类对象

1. public class study01 {
2.         public static void main(String[] args) {
3.      // 请问构建了多少个父类对象
4.      Son son1 = new Son();
5.      Son son2 = new Son();
6.      Son son3 = new Son();
7.         }
8. }
9. //父类
10. class Father{
11.         void say(){
12.                 System.out.println("我是说话了");
13.         }
14. }
15. //子类继承父类
16. class Son extends Father{
17.        
18. }  

复制代码

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

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.      Son son1 = new Son();
4.      Son son2 = new Son();
5.      Son son3 = new Son();
6.         }
7. }
9. //父类
10. class Father{
11.         Father(){
12.                 System.out.println("构造方法");
13.         }
14. }
15. //子类继承父类
16. class Son extends Father{
17.        
18. }  
19. 在控制台输出了3次。
20. 说明确实是构造了 3个父类对象

复制代码

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

1. public class study01 {
2.         public static void main(String[] args) {
3.      Son son1 = new Son();
4.         }
5. }
7. //父类
8. class Father{
9.         String userName;
10.         // 父类提供了构造方法
11.         Father(String name){
12.                 userName = name;
13.                 System.out.println("构造方法" + userName);
14.         }
15. }
16. //子类继承父类
17. class Son extends Father {
18.         Son(){
19. //  如果父类提供了构造方法，那么JVM不会提供默认的构造方法，此时子类应该显示调用super方法构建父类对象
20.           super("张三");
21.         }
22. }  

复制代码

new只会构建一个对象

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

复制代码

多态

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

复制代码

1. public class study01 {
2.         public static void main(String[] args) {
3.                 Person p1 = new Person();
4.                 Person p2 = new Body();
5.                 Person p3 = new Girl();
6.         }
7. }
9. class Person{
10. }
11. class Body extends Person {
12. }
13. class Girl extends Person {
14. }

复制代码

多态的一个表现

1. public class study01 {
2.         public static void main(String[] args) {
3.                 Person p1 = new Person();
4.                 Person p2 = new Body();
5.     //                p2.testBody(); // 会报错
6.                 p2.testPerson(); // 正常的
7.                 Person p3 = new Girl();
8.         }
9. }
12. class Person{
13.         void testPerson(){
14.                 System.out.println("testPerson");
15.         }
16. }
18. class Body extends Person {
19.         void testBody(){
20.                 System.out.println("testBody");
21.         }
22. }
23. class Girl extends Person {
24.         void testGirl(){
25.                 System.out.println("testGirl");
26.         }
27. }

复制代码

                                                                                                                                                                        微信                                                                                                本文版权归作者所有，欢迎转载，未经作者同意须保留此段声明，在文章页面明显位置给出原文连接
                        如果文中有什么错误，欢迎指出。以免更多的人被误导。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！