1.成员变量：隶属于对象的变量，用于保存对象的静态特征，同类型的不同对象拥有相同的成员
2.方法：用于完成特定功能的整段代码，对代码进行封装。
package test;
public class Method {
// 这是一个isOddNumber方法，String表示的方法的返回类型
public String isOddNumber(int num) {
System.out.println("原来的数字是："+num);
if(num%2==0) {
return "偶数";
}else {
return "奇数";
}
}
public static void main(String[] args) {
// 创建一个对象
Method method1 = new Method();
int a = 10;
// 这里的 String是方法的返回类型，必须一致
String num1 = method1.isOddNumber(a);
System.out.println(a+"是一个" +num1);
}
}
3.包（package）：将功能详实的或相关的类组织在一个包中，以目录形式保存，也可限定累的访问权限。
包的命名规则：域名后缀.组织机构名.项目名[.模块名].包的职能
import 关键字：用于导入不同包下的类 import +包名 ，但是同一个包下的不同类不需要导入
4.访问修饰符：用于控制类、成员变量、方法的访问范围。
private （私有）： 只能在类的内部访问
public （公有） ： 在任何地方都可以访问
default （默认）： 相同包的其他类可以访问
protected （继承）： 只有继承的子类可以访问
5.面向对象的三大特征：封装、继承、多态；
1.封装：隐藏功能的实现细节，利用好对象和方法是实现封装的直接途径
如果成员变量是是私有的，则需要使用getter方法
package test;
public class Method {
//成员变量私有化
private String owner; //所有者
private String areaCode ="86";//国家区号
private long mobileNumber;//手机号
//getter 方法 ，用于读写成员变量的内容，格式为public 成员变量类型 get成员变量名（）
public String getOwner() {
//this 关键字代表当前的对象。。。。
return this.owner;
}
// setter 方法，用于设置成员变量的内容，格式为public void set成员变量名（新的数据参数）
public void setOwner (String owner) {
// this.owner代表当前的对象,owner代表新的数据参数
this.owner = owner;
}
public String getAreaCode() {
//this 关键字代表当前的对象。。。。
return this.areaCode;
//因为areaCode是固定的不可改变，所以只能读不能写，故只有get方法，没有set方法
}
}
//在其他类中的使用
Method method1 = new Method();
//先设置在读取
method1.setOwner("lucy");
String owner = method1.getgetOwner();
System.out.println(owner);
String areaCode = method1.getgetOwner();
System.out.println(areaCode);
2.继承：用extends关键字使用，子类继承父类的（default ）、protected、public 修饰的成员变量与方法
//父类
package test;
public class Method {
protected String title;
protected String color;
protected String movie;
public void description() {
System.out.println("型号"+title);
System.out.println("颜色"+color);
System.out.println("首次出现的电影"+movie);
}
private void fire() {
System.out.println("利用手臂射出火焰");
}
public static void main(String[] args) {
Method method1 = new Method();
method1.color ="银灰色";
method1.movie = "钢铁侠1";
method1.title = "马克1型";
method1.description();
method1.fire();
}
//子类
package test;
public class Methodd extends Method {
private void createShield() {
System.out.println("生成护盾");
}
public static void main(String[] args) {
Methodd methodd1 = new Methodd();
methodd1.title ="防浩克装甲";
methodd1.color ="红色";
methodd1.movie ="复仇者联盟3";
methodd1.description();
methodd1.createShield();
}
}
3.多态 ：同一种行为具有多个不同的表现形式或形态的能力，实现多态的关键是接口
接口（interface）：是一种抽象的类型，只提供方法的定义
实现类：实现特定接口的具体实现，要实现每一个接口方法的功能
package test;
public class Chinese implements Language{
@Override //重写
public void voice() {
System.out.println("你好，有什么可以帮助你？");
}
}
package test;
public class English implements Language{
@Override
public void voice() {
System.out.println("Hi,may i help you?");
}
}
package test;
public class French implements Language{
@Override
public void voice() {
System.out.println("nihao?");
}
}
package test;
//实现接口的类
public class CustomerService {
public Language contact (int areaCode) {
if(areaCode == 86) {
return new Chinese();
}else if(areaCode == 33){
return new French();
}else {
return new English();
}
}
public static void main(String [] args) {
// 接口的实例化---- Language接口名字 english对象 English()实现类的名字
Language english = new English();
english.voice();
CustomerService cs = new CustomerService();
Language language = cs.contact(86);
language.voice();
}
}
package test1;
import test.CustomerService;
import test.Language;
public class Customer {
public static void main(String[] args) {
CustomerService cs1 = new CustomerService();
Language language = cs1.contact(86);
language.voice();
}
}
ArrayList类：java中内置的数据集合，用于存储多个数据，是数组的替代品，提供更多的数据操作的方法。
package test1;
import java.util.ArrayList;
import java.util.List;
public class ArrayList1 {
public static void main(String[] args) {
// 相当于接口名与实现类之间的关系,<String>集合类型为字符型，这是一种泛型
List<String> bookList = new ArrayList<String>();
bookList.add("红楼梦");
bookList.add("西游记");
bookList.add("水浒传");
bookList.add("三国演义");
bookList.add(0, "镜花缘");
System.out.println(bookList);
// get方法只需要传入索引
String bookName = bookList.get(2);
System.out.println(bookName);
int size = bookList.size();
System.out.println(size);
bookList.remove(1);
System.out.println(bookList);
bookList.remove(bookList.size()-1);
System.out.println(bookList);
for (String book : bookList) {
System.out.println("《"+book+"》");
}
}
}
java其它语法
1、 一旦一个字符串在内存中创建，则这个字符串将不可改变。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder。
2、 每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,如果只需比较内容是否相同，应使用 ”equals()” 方法。
3、 StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。
public class HelloWorld {
public static void main(String[] args) {
// 创建一个StringBuilder对象，用来存储字符串
StringBuilder hobby=new StringBuilder("爱慕课");
System.out.println(hobby);
// 创建一个空的StringBuilder对象
StringBuilder str = new StringBuilder();
// 追加字符串
str.append("jaewkjldfxmopzdm");
// 从后往前每隔三位插入逗号
for(int i=str.length()-3;i>0;i=i-3){
str.insert(i,',');
}
// 将StringBuilder对象转换为String对象并输出
System.out.print(str.toString());
}
}
友情提示：
- 字符串 str 中字符的索引从0开始，范围为 0 到 str.length()-1
- 使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1
- 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符
public class HelloWorld {
public static void main(String[] args) {
// Java文件名
String fileName = "HelloWorld.java";
// 邮箱
String email = "laurenyang@imooc.com";
// 判断.java文件名是否正确：合法的文件名应该以.java结尾
/*
参考步骤：
1、获取文件名中最后一次出现"."号的位置
2、根据"."号的位置，获取文件的后缀
3、判断"."号位置及文件后缀名
*/
//获取文件名中最后一次出现"."号的位置
int index = fileName.lastIndexOf(".");
// 获取文件的后缀
String prefix =fileName.substring(index+1,fileName.length());
// 判断必须包含"."号，且不能出现在首位，同时后缀名为"java"
if ( index!=-1&&index!=0&&prefix.equals("java")) {
System.out.println("Java文件名正确");
} else {
System.out.println("Java文件名无效");
}
// 判断邮箱格式是否正确：合法的邮箱名中至少要包含"@", 并且"@"是在"."之前
/*
参考步骤：
1、获取文件名中"@"符号的位置
2、获取邮箱中"."号的位置
3、判断必须包含"@"符号，且"@"必须在"."之前
*/
// 获取邮箱中"@"符号的位置
int index2 = email.indexOf('@');
// 获取邮箱中"."号的位置
int index3 = email.indexOf('.');
// 判断必须包含"@"符号，且"@"必须在"."之前
if (index2 != -1 && index3 > index2) {
System.out.println("邮箱格式正确");
} else {
System.out.println("邮箱格式无效");
}
}
}
“==” 和 equals() 有什么区别呢？
==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象
equals(): 比较存储在两个字符串对象中的内容是否一致
public class HelloWorld {
public static void main(String[] args) {
// 定义一个字符串
String s = "aljlkdsflkjsadjfklhasdkjlflkajdflwoiudsafhaasdasd";
// 出现次数
int num = 0;
// 循环遍历每个字符，判断是否是字符 a ，如果是，累加次数
for (int i=0;i<s.length();i++)
{
// 获取每个字符，判断是否是字符a
if (s.charAt(i)=='a' ) { //依次获取每个字符，判断是否是字符a
// 累加统计次数
num++;
}
}
System.out.println("字符a出现的次数：" + num);
}
}
java中的包装类( java.lang)
Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。
基本类型和包装类之间的对应关系：
public class HelloWorld {
public static void main(String[] args) {
int score1 = 86;
Integer score2=new Integer(score1); // 创建Integer包装类对象，表示变量score1的值
double score3=score2.doubleValue(); // 将Integer包装类转换为double类型
float score4=score2.floatValue(); // 将Integer包装类转换为float类型
int score5 =score2.intValue(); // 将Integer包装类转换为int类型
System.out.println("Integer包装类：" + score2);
System.out.println("double类型：" + score3);
System.out.println("float类型：" + score4);
System.out.println("int类型：" + score5);
}
}
public class HelloWorld {
public static void main(String[] args) {
// 定义double类型变量
double a = 91.5;
// 手动装箱,装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
Double b = new Double(a);
// 自动装箱
Double c = a;
System.out.println("装箱后的结果为：" + b + "和" + c);
// 定义一个Double包装类对象，值为8
Double d = new Double(87.0);
// 手动拆箱,拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
double e = d.doubleValue();
// 自动拆箱
double f = d;
System.out.println("拆箱后的结果为：" + e + "和" + f);
}
}
基本类型转换为字符串有三种方法：
- 使用包装类的 toString() 方法
- 使用String类的 valueOf() 方法
- 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串
字符串转换成基本类型有两种方法：
- 调用包装类的 parseXxx 静态方法
- 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱
public class HelloWorld {
public static void main(String[] args) {
double m = 78.5;
//将基本类型转换为字符串
//1.使用包装类的 toString() 方法
String str1 = Double.toString(m);
// 2. 使用String类的 valueOf() 方法
// String str1 = String.valueOf(m);
// 3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串
// String str1 = m + "";
System.out.println("m 转换为String型后与整数20的求和结果为： "+(str1+20));
String str = "180.20";
// 将字符串转换为基本类型
// 1. 调用包装类的 parseXxx 静态方法
Double a = Double.parseDouble(str);
//2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱
//Double a = Double.valueOf(str);
System.out.println("str 转换为double型后与整数20的求和结果为： "+(a+20));
}
}
Date类和SimpleDateFormat 类表示时间
- 使用 format() 方法将日期转换为指定格式的文本
- 使用 parse() 方法将文本转换为日期
- 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理
- 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class HelloWorld {
public static void main(String[] args) throws ParseException {
// 使用format()方法将日期转换为指定格式的文本
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm");
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date now = new Date(); // 创建Date对象，表示当前时间
// 调用format()方法，将日期转换为字符串并输出
System.out.println(sdf1.format(now));
System.out.println(sdf2.format(now));
System.out.println(sdf3.format(now));
// 使用parse()方法将文本转换为日期
String d = "2014-6-1 21:05:36";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(d); // 调用parse()方法，将字符串转换为日期
System.out.println(date);
}
}
java.util.Calendar 类
- java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();
- Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class HelloWorld {
public static void main(String[] args) {
Calendar c = Calendar.getInstance(); // 创建Calendar对象
Date date = c.getTime(); // 将Calendar对象转换为Date对象
Long time = c.getTimeInMillis(); //获取当前毫秒数
// 创建SimpleDateFormat对象，指定目标格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将日期转换为指定格式的字符串
String now = sdf.format(date);
System.out.println("当前时间：" + now);
}
}
Math 类位于 java.lang 包
public class HelloWorld {
public static void main(String[] args) {
// 定义一个整型数组，长度为10
int[] nums = new int[10];
//通过循环给数组赋值
for (int i = 0; i < nums.length; i++) {
// 产生10以内的随机数
int x = (int) (Math.random()*10);//产生10以内的随机数
nums[i] = x;// 为元素赋值
}
// 使用foreach循环输出数组中的元素
for ( int num :nums) {
System.out.print(num + " ");
}
}
}
java集合框架
集合与数组的区别：
1.数组长度一定，集合长度可变
2.数组只能通过下标访问元素，类型固定，而集合可以通过任意类型查找所映射的具体对象。
Collection根接口：List子接口（ArrayList类，LinkedList类）Queue子接口（LinkedList类）Set子接口（HashSet类） 单个存储
Map根接口：（HashMap类） 键值对存储
List子接口：list是元素有序并且重复的集合，可以使用get（）方法
List子接口：可以精确的控制每个元素的插入删除位置
泛型：规定某个集合只能存放特定类型的对象会在编译期间进行类型检查(必须是引用类型)
集合：里面的元素可以是任意类型的对象（对象的引用），如果把某个对象放入集合，则会忽略它的类型，将其当作Object处理
Set子接口（HashSet类） ：无序且不可重复的集合称为集，只能用foreach和interator（迭代器）方法，不可以使用get（）方法
7035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
