java学习

java learning

Posted by fa1con on February 1, 2019

java

第一个程序

src目录下创建一个package,package下创建一个class类型的java文件,demo如下

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.fun.demo;

public class helloworld {
    public static void main(String[] args){
        String[] greeting = new String[3];
        greeting[0]="Hello World";
        greeting[1]="by Cay Horstmann";
        greeting[2]="and Gary Cornell";
        for (String g : greeting){
            System.out.println(g);
        }
    }
}

第二个程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.*;
public class HelloWorld {
    public static void main(String[] args) {
        int[] scores = {89,-23,64,91,119,52,73};
        System.out.println("考试成绩的前三名为:");
        HelloWorld Mysort = new HelloWorld();
        Mysort.mysort(scores);
    }
    //定义方法完成成绩排序并输出前三名的功能
    public void mysort(int[] scores){
        Arrays.sort(scores);//排序
        int count = 0;
        for(int i = 0;i < scores.length && count < 3;i++){
            if(scores[i] > 100 || scores[i] < 0){
                continue;
            }else{
                count++;
                System.out.println(scores[i]);
            }
        }
    }
}

数据类型

image 还有String类型 基本数据类型变量存的是数据本身,而引用类型变量存的是保存数据的空间地址 单字符用单引号,多字符用双引号。 字符拼接用+ 强制类型转换和C一样

final String LOVE = “IMOOC”; 使用final定义的常量运行过程中不能改变 布尔值不可以与整型值相互转换,这与C++中非0则为真不同:JAVA要求明确使用布尔类型,而不是0和1 声明一个变量以后,一定要对变量进行赋值初始化 字符串的子串需要使用substring方法来提取,而不像python的切片操作符[]方便

Arrays操作数组

1.Arrays.sort(数组名); 2.Arrays.toString(数组名);将一个数组转换成字符串,可以理解为python的列表输出。

函数重载

image 根据参数类型选择重载方法 判断方法重载的依据: 1、 必须是在同一个类中 2、 方法名相同 3、 方法参数的个数、顺序或类型不同 4、 与方法的修饰符或返回值没有关系

类和对象

成员变量和局部变量

成员变量可以与局部变量重名,局部变量具有更高的优先级

构造方法

new+构造方法,构造方法与类名称相同 无指定构造方法时,系统自动添加无参构造方法,跟C++一样 重载跟C++一样 ```java //Telphone.java package com.fun;

public class Telphone { float screen; float cpu; float mem; public Telphone(){ System.out.println(“无参构造方法”); } public Telphone(float newScreen,float newCpu,float newMen){ screen = newScreen; cpu = newCpu; mem = newMen; System.out.println(“有参的构造方法行了”); } }

1
2
3
4
5
6
7
8
9
10
```java
//InitTelphone.java
package com.fun;

public class InitTelphone {
    public static void main(String[] args){
        Telphone phone = new Telphone();
        Telphone phone2 = new Telphone(5.0f,1.4f,2.0f);
    }
}

static使用

希望该类的所有对象共享同一个成员 被static修饰的成员称为静态成员或类成员,被该类所有对象所共享

1
2
3
4
5
6
7
8
9
public class HelloWorld {
    // 定义静态变量,保存班级名称
	static String className = "JAVA开发一班";
	public static void main(String[] args) {
        HelloWorld demo = new HelloWorld();
		// 访问静态变量,输出班级名称
		System.out.println(demo.className);
	}
}

static修饰方法称为静态方法或类方法 如果希望在静态方法中调用非静态变量,可以通过创建类的对象,然后通过对象来访问非静态变量 在普通成员方法中,则可以直接访问同类的非静态变量和静态变量 静态方法中不能直接调用非静态方法,需要通过对象来访问非静态方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class HelloWorld {
    // 定义静态变量score1
    static int score1 = 86;
    // 定义静态变量score2
	static int score2 = 92; 
	public static int sum() { 
    		HelloWorld score = new HelloWorld();
        	int allScore;  
        	allScore = score.score1 + score.score2;
        	return allScore;
	}

	public static void main(String[] args) {
		int allScore = sum();
		System.out.println("总分:" + allScore);
	}
}

static与静态初始化块

在类的声明中,可以包含多个初始化块,当创建类的实例时,就会依次执行这些代码块。如果使用 static 修饰初始化块,就称为静态初始化块。

静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量 ```java public class HelloWorld { String name; // 声明变量name String sex; // 声明变量sex static int age;// 声明静态变量age // 构造方法 public HelloWorld() { System.out.println(“通过构造方法初始化name”); name = “tom”; } // 初始化块 { System.out.println(“通过初始化块初始化sex”); sex = “男”; } // 静态初始化块 static { System.out.println(“通过静态初始化块初始化age”); age = 20; }

1
2
3
4
5
6
7
public void show() {
	System.out.println("姓名:" + name + ",性别:" + sex + ",年龄:" + age);
}
public static void main(String[] args) {
	HelloWorld hello = new HelloWorld();
    hello.show();
} } ``` 运行结果 ``` 通过静态初始化块初始化age 通过初始化块初始化sex 通过构造方法初始化name 姓名:tom,性别:男,年龄:20 ``` >静态初始化最先执行 ## 封装 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问 实现: 1.修改属性的可见性(`private`) 2.创建getter/setter方法 3.在getter/setter方法加入属性控制语句 ### 包 管理java文件,解决同名文件冲突 例子: ```java com.imooc.music.MyClassMusic com.imooc.movie.MyClassMusic ``` 常见系统包 ``` java.lang.(类) //java语言基础的类 java.util.(类) //包含java语言中各种工具类 java.io.(类) //输入输出相关功能的类 ```

使用import 某包名导入包

访问修饰符

image

this

区分属性与参数的概念 指代当前对象

内部类

内部类是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。 更好的封装,不允许同一个包中的其他类访问该类 内部类的方法可以直接访问外部类的所有数据,包括私有的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HelloWorld {
    // 内部类Inner,类Inner在类HelloWorld的内部
    public class Inner {
		// 内部类的方法
		public void show() {
			System.out.println("welcome to imooc!");
		}
	}
	public static void main(String[] args) {   
        // 创建外部类对象
		HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        //定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );
		Inner i = hello.new Inner();
        // 调用内部类对象的方法
		i.show();
	}
}

成员内部类

定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );

编译上面的程序后,会发现产生了两个 .class 文件,第二个是外部类的 .class 文件,第一个是内部类的 .class 文件,即成员内部类的 .class 文件总是这样:外部类名$内部类名.class

如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,使用外部类名.this.变量,如下列demo的HelloWorld.this.name

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class HelloWorld{
    private String name = "imooc";
    int age = 20;
	public class Inner {
		String name = "爱慕课";
		public void show() { 
			System.out.println("外部类中的name:" + HelloWorld.this.name );
			System.out.println("内部类中的name:" + name);
			System.out.println("外部类中的age:" + age);
		}
	}   
	public static void main(String[] args) {
		HelloWorld o = new HelloWorld (); 
		Inner inn = o.new Inner();
		inn.show();
	}
}

静态内部类

静态内部类不能直接访问外部类的非静态成员,但可以通过new 外部类().成员的方式访问 创建静态内部类的对象时,不需要外部类的对象,可以直接创建内部类 对象名= new 内部类() 如果外部类的静态成员与内部类的成员名称相同,可通过“类名.静态成员”访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过“成员名”直接调用外部类的静态成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HelloWorld {
    private static int score = 84;
	public static class SInner {
        int score = 91;
		public void show() {
			System.out.println("访问外部类中的score:" + HelloWorld.score);
			System.out.println("访问内部类中的score:" + score);
		}
	}
	public static void main(String[] args) {
        SInner si = new SInner();
		si.show();
	}
}

方法内部类

方法内部类就是内部类定义在外部类的方法中,方法内部类只在该方法的内部可见,即只在该方法内可以使用。

由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符static修饰符。 ```java public class HelloWorld { private String name = “爱慕课”; public void show() { // 定义方法内部类 class MInner { int score = 83; public int getScore() { return score + 10; } } MInner o = new MInner(); int newScore = o.getScore(); System.out.println(“姓名:” + name + “\n加分后的成绩:” + newScore); }

1
2
3
4
public static void main(String[] args) {
    HelloWorld mo = new HelloWorld();
	mo.show();
} } ``` ## 继承 语法:`class 子类 extends 父类` ### 方法重写 返回值类型,方法名,参数都一样才算`重写` 跟写一个函数没有区别 `final`关键字修饰的类或者方法,不允许被继承或被重写,`写在public之前` `final`修饰变量(属性)一定要初始化 ### super 在子类对象内部使用,可代表父类对象 1.访问父类的属性`super.xxx` 2.访问父类的方法`super.xxx()`