java基础
1.1 windows安装
看起来你正在描述如何在Windows上安装Java开发工具包（JDK）并验证安装是否成功。以下是一些步骤的总结：
-
下载Java JDK ：
- 前往 "products→java→download java now" 网站选择需要的Java版本并下载。
-
安装：
- 安装时注意不要在安装路径中使用空格，最好选择D盘或其他无中文字符的盘符。
- 例如，安装路径可以选择为 D:\Java\jdk-17。
-
执行工具：
- 安装完成后，在安装目录的bin文件夹中可以找到以下重要的执行工具：
- java.exe：用于执行Java程序。
- javac.exe：用于编译Java源代码。
- 安装完成后，在安装目录的bin文件夹中可以找到以下重要的执行工具：
-
验证安装是否成功：
- 打开命令提示符（Cmd）。
- 输入以下命令来检查Java和javac版本：
java -version javac -version - 如果成功安装，将会显示Java版本信息和javac版本信息。
在你的示例中，javac版本为17，但Java版本为1.8.0_291。这表明你的Java版本和javac版本不匹配，可能需要检查你的安装，确保安装的JDK版本与你希望使用的版本一致。此外，你还可以配置环境变量，以便在任何位置都可以访问Java和javac。
1.2 linux安装
sudo apt-get update
需要oracle官网看看最新版本是多少
sudo apt-get install openjdk-17-jdk
查看版本
java -version
package com.yys534640040;
public class switchDemo {
public static void main(String[] args) {
int month = 2;
switch (month){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月,31天");
break;
case 2:
System.out.println(month + "月,平年28天,闰年29天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月,30天");
break;
}
}
}
switch分支注意事项:
①表达式类型只能是byte、short、int、char,JDK5开始支持枚举，JDK7开始支持String.
不支持double、float、long。
②case给出的值不允许重复，且只能是字面量，不能是变量。
③不要忘记写break，否则会出现穿透现象。
package com.yys534640040.array;
public class ArrayDemo {
public static void main(String[] args) {
// 1.静态初始化
int [] arr = {22, 34, 55};
for (int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
//2.动态初始化
int [] arr2 = new int[6];
arr2[2] = 100;
System.out.println(arr2[2]);
}
}
两种初始化的的使用场景总结、注意事项说明:
动态初始化:只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
静态初始化:开始就存入元素值，适合一开始就能确定元素值的业务场景。
两种格式的写法是独立的严，不可以混用。
1.动态初始化数组后元素的默认值是什么样的?
byte、short、int . char、long类型数组元素的默认值都是0,float、double类型数组元素的默认值都是0.0
boolean类型数组元素的默认值是false、String类型数组元素的默认值是null
如何得到类的对象
| 类名对象名= new类名(); |
| Car c = new Car(); |
如何使用对象
访问属性:对象名.成员变量访问行为:对象名.方法名(.….)
目录
└── object
├── Car.java
└── Test.java
|
|
输出结果
宝马, 价格是78.0万元, 启动了
宝马, 价格是78.0万元, 跑的很快
1.定义类有哪些建议，有什么需要注意的?
类名首字母建议大写、英文、有意义，满足驼峰模式，不能用关键字，满足标志符规定;一个代码文件中可以定义多个类，但是只能一个类是public修饰的，public修饰的类名必须是Java代码的文件名称。
2.成员变量的格式是什么样的，有什么特点?
成员变量的完整定义格式是:修饰符数据类型变量名称=初始化值;一般无需指定初始化值，存在默认值。
1.对象放在哪个位置?
堆内存中
2.Car c = new Car();c变量名中存储的是什么?
存储的是对象在堆内存中的地址。
3.成员变量(name、price)的数据放在哪里，存在于哪个位置?
●对象中，存在于堆内存中。
目录
└── thisdemo
├── Car.java
└── Test.java
|
|
输出结果
宝马
34.4
-------------
com.yys534640040.thisdemo.Car@4eec7777
com.yys534640040.thisdemo.Car@4eec7777
宝马正在和奔驰比赛
1. this关键字的作用?
代表当前对象的地址。
2. this关键字在构造器中、成员方法中可以做什么?
可以用于访问当前对象的成员变量
|
|
封装的实现步骤
一般对成员变量使用private(私有)关键字修饰进行隐藏，private修饰后该成员变量就只能在当前类中访问。提供public修饰的公开的getter、setter方法暴露其取值和赋值。
封装的好处小结
加强了程序代码的安全性。
适当的封装可以提升开发效率，同时可以让程序更容易理解与维护。
成员变量和局部变量的区别
|
区别 |
成员变量 |
局部变量 |
|
类中位置不同 |
类中，方法外 |
常见于方法中 |
|
初始化值不同 |
有默认初始化值 |
没有，使用之前需要完成赋值 |
|
内存位置不同 |
堆内存 |
栈内存 |
|
生命周期不同 |
随着对象的创建而存在，随着对象的消失而消失 |
随着方法的调用而存在，随着方法的运行结束而消失 |
|
作用域 |
|
在所归属的大括号中 |
1.String是什么，可以做什么?
●字符串类型，可以定义字符串变量指向字符串对象。
2.String是不可变字符串的原因?
String变量每次的修改其实都是产生并指向了新的字符串对象。
●原来的字符串对象都是没有改变的，所以称不可变子付串。
2.比较
package com.yys534640040.String;
import java.util.Scanner;
public class Equals {
public static void main(String[] args) {
String username = "Yys";
String passwd = "123456";
Scanner sc = new Scanner(System.in);
System.out.println("登录名字");
String name = sc.next();
System.out.println("登录密码");
String pass = sc.next();
// 1.区分大小写比较
if (username.equals(name) && passwd.equals(pass)){
System.out.println("登陆成功");
}else {
System.out.println("密码或账号不正确");
}
// 2. 忽略大小写比较
String s1 = "AbdsdS";
String s2 = "abdsds";
System.out.println(s1.equalsIgnoreCase(s2));
}
}
字符串的内容比较:
推荐使用String类提供的“equals”比较:只关心内容一样即可
|
方法名
|
说明 |
|
public boolean equals (object anobject)
|
将此字符串与指定对象进行比较。只关心字符内容是否—致!
|
|
public boolean equalsIgnoreCase (string anotherString)
|
将此字符串与指定对象进行比较，忽略大小写比较字符串。只关心字符内容是否一致!
|
String类主要方法的使用：
一、获取长度
public int length(); // 这与数组中的length属性获取长度不同
二、比较相等
== //判断内容与地址是否相同
public boolean equals(Object anObject);//判断内容是否相同
public boolean equalsIgnoreCase(String anotherString);//忽略大小写的情况下判断内容是否相同
如果想对字符串中的部分内容是否相同进行比较，可以用reagionMatches() 有两种
public boolean regionMatches(int toffset, String other,int ooffset,int len);表示如果String对象的一个子字符串与参数other的一个子字符串是相同的字符序列，则为true.要比较的String对象的字符串从索引toffset开始，other的字符串从索引ooffset开始，长度为len。
public boolean reagionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len);//用布尔类型的参数指明两个字符串的比较是否对大小写敏感。
三、比较大小
public int compareTo(String anotherString); //判断字符串的大小关系
public int compareToIgnoreCase(String str); //在比较时忽略字母大小写
四、查找字符串中某个位置的字符
public char charAt(int index);//返回指定索引index位置上的字符，索引范围从0开始
五、查找指定字符串在字符串中第一次或最后一词出现的位置
在String类中提供了两种查找指定位置的字符串第一次出现的位置的方法
public int indexOf(String str);//从字符串开始检索str，并返回第一次出现的位置，未出现返回-1
public int indexOf(String str,int fromIndex);//从字符串的第fromIndex个字符开始检索str
查找最后一次出现的位置有两种方法
public int lastIndexOf(String str);
public int lastIndexOf(String str,int fromIndex);
如果不关心字符串的确切位置则可使用
public boolean contains(CharSequence s);
六、检查字符串的起始字符和结束字符
开始的字符串两种方法
public boolean starWith(String prefix,int toffset);//如果参数prefix表示的字符串序列是该对象从索引toffset处开始的子字符串，则返回true
public boolean starWith(String prefix);
结束的字符串方法
public boolean endsWith(String suffix);
七、截取子串
public String subString(int beginIndex);// 返回以beginIndex开头直至该字符串结尾的串
public String subString(int beginIndex,int endIndex);//返回的字符串是从beginIndex开始到endIndex-1的串，要返回后4位可以这样写Syetem.out.println(*.subString()(*.length()-4));
八、字符串的替换
public String replace(char oldChar,char newChar);
public String replace(CharSequence target,CharSequence replacement);//把原来的etarget子序列替换为replacement序列，返回新串
public String replaceAll(String regex,String replacement);//用正则表达式实现对字符串的匹配
九、字符串的大小写替转换
public String toLowerCase(Locale locale);
public String toLowerCase();
public String toupperCase(Locale locale);
public String toUpperCase();
十、去除字符串首尾空格
public String trim();
十一、字符串转换
1、将字符串转换成字符数组
public char[] toCharArray();
2、将字符串转换成字符串数组
public String[] split(String regex);//regex 是给定的匹配
3、将其它数据类型转化为字符串
public static String valueOf(boolean b);
public static String valueOf(char c);
public static String valueOf(int i);
public static String valueOf(long i);
public static String valueOf(float f);
public static String valueOf(double d);
public static String valueOf(char[] data);
public static String valueOf(Object obj);
4、可变字符串的创建和初始化，两种方法:
public StringBuffer();
public StringBuffer(int caoacity);
StringBuffer类主要方法的使用：
一、获取可变字符串长度
public int length();
public int capacity();
public void setLength(int newLength);
二、比较可变字符串
用String 类的equals()方法比较，但是不同。类Object中的equals()方法比较的是两个对象的地址是否相等，而不仅仅是比较内容，但是String类在继承Object类的时候重写了equals()方法，只是比较两个对象的内容是否相等，而在StringBuffer类中没有重写Object类的equals()方法，所以比较的是地址和内容。
三、追加和插入字符串
追加
public StringBuffer append(type t);
插入
public StringBuffer insert(int offset,type t); //在offset处加入类型为type的字符串
四、反转和删除字符串
反转
public StringBuffer reverse();
删除
public StringBuffer delete(int start,int end);
五、减少用于可变字符序列的存储空间
public void trimToSize();
六、StringBuffer类转换成String类
public String toString();
package com.yys534640040.arraylist;
import java.util.ArrayList;
public class ArrayListDemo {
public static void main(String[] args) {
// 1.创建ArrayList集合对象
ArrayList list = new ArrayList();
// 2. 添加元素
list.add("y");
list.add("y");
list.add("s");
// 3.指定索引添加元素
list.add(2, "kkk");
System.out.println(list);
}
}
泛型概述
ArrayList<E>:其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。
举例:
ArrayList<String> :此集合只能操作字符串类型的元素。
ArrayList<lnteger>:此集合只能操作整数类型的元素。
注意:集合中只能存储引用类型，不支持基本数据类型。
package com.yys534640040.arraylist;
import java.util.ArrayList;
public class ArrayListdemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(); // 范行第二个尖括号可以不写声明
list.add("34");
// list.add(2);
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(2);
}
}
ArrayList集合常用方法
方法名 说明
public boolean remove(Object o) 删除指定的元素，返回删除是否成功
public E remove(int index) 删除指定索引处的元素，返回被删除的元素
public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
public E get(int index) 返回指定索引处的元素
public int size() 返回集合中的元素的个数
get()方法
作用：根据下标获取集合中的元素;
参数：下标位置(0——(list.size()-1)之间);
返回：集合中的元素;
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");
list.add("str4");
String str=list.get(2);
System.out.println(str);//输出：str3
size()方法
作用：获取集合中的元素个数;
参数：无;
返回：int类型,集合的元素个数;
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");
list.add("str4");
int n=list.size();
System.out.println(n);//输出：4
clear()方法
作用：清除集合中的所有元素;
参数：无;
返回：无;
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
System.out.println(list);//输出：[str1, str2]
list.clear();
System.out.println(list);//输出：[]
contains()方法
作用：判断集合内是否存在指定元素;
参数：指定元素;
返回：boolean(true表示存在,false表示不存在);
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");
list.add("str4");
System.out.println(list.contains("str2"));//输出：true
System.out.println(list.contains("str5"));//输出：false
indexof()方法
作用：查找集合内的元素;
参数：需要查找的元素;
返回：int类型(找到返回下标,未找到返回-1);
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");
list.add("str4");
System.out.println(list.indexof("str2"));//输出：1
System.out.println(list.indexof("str5"));//输出：-1
remove()方法
作用：删除集合内的元素;
参数：①指定下标位置;②指定元素;
返回：①指定下标位置删除返回删除的元素值;②指定元素输出返回ture;
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");
list.add("str4");
System.out.println(list.remove(1));//输出：str2
System.out.println(list.remove("str4"));//输出：true
set()方法
作用：将指定下标位置改为指定元素;
参数：指定下标，指定元素;
返回：修改前的原值;
ArrayList<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");
list.add("str4");
System.out.println(list);//输出：[str1, str2, str3, str4]
System.out.println(list.set(1,"str5"));//输出：str2
System.out.println(list);//输出：[str1, str5, str3, str4]
toArray()方法
作用：将集合转换为数组;
参数：①无参;②其他类型的数组对象;
返回：①Object[ ];②指定类型的数组;
// 快速创建并初始化一个List集合
// 该集合对象类型为Arrays类的内部类ArrayList
List<String> list1 = Arrays.asList("str1", "str2", "str3", "str4", "str5", "str6");
// 将集合内所有元素添加至heroList02
ArrayList<String> list2 = new ArrayList<String>();
list2.addAll(list1);
Object[] array01 = list2.toArray(); //转换成Object数组
String[] array02 = list2.toArray(new String[0]); // 转换成String类型数组
subList()方法
作用：在原集合中截取子集合;
参数：开始下标, 结束下标;
返回：子集合;
List<String> list1 = Arrays.asList("str1", "str2", "str3", "str4", "str5", "str6");
ArrayList<String> list2 = new ArrayList<String>();
list2.addAll(list1);
//截取(0,3),即为0,1,2三个元素,区间[0,3)
List<String> result= list2.subList(0, 3);
System.out.println(result);//输出：[str1, str2, str3]
sort()方法
作用：对集合中的元素排序;
参数：Comparator比较器接口实现类对象;
返回：无;
List<String> list1 = Arrays.asList("str8", "str4", "str6", "str3", "str2", "str9");
ArrayList<String> list = new ArrayList<String>();
list.addAll(list1);
//new Comparator<String>()采用了匿名类对象，直接实现compare()方法
list.sort(new Comparator<String>() {
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
System.out.println(list);//输出：[str2, str3, str4, str6, str8, str9]
ArrayList集合的遍历
List<String> list1 = Arrays.asList("str1", "str2", "str3", "str4", "str5", "str6");
ArrayList<String> list = new ArrayList<String>();
list.addAll(list1);
// 方式1：使用for循环遍历集合list
for (int i = 0, len = list.size(); i < len; i++) {
//输出：str1,str2,str3,str4,str5,str6,
System.out.print(list.get(i)+",");
}
System.out.println("-----------------------------------");
// 方式2：使用迭代器遍历集合list
// (1)获取当前集合对象的迭代器对象
Iterator<String> it = list.iterator();
// (2)使用迭代器遍历每个元素
while (it.hasNext()) { //判断集合是否有下一个元素
//输出：str1,str2,str3,str4,str5,str6,
System.out.print(it.next()+",");//获取集合的下一个元素
}
System.out.println("-----------------------------------");
// 方式3 : foreach遍历list
for(String str : list) {
//输出：str1,str2,str3,str4,str5,str6,
System.out.print(str+",");
}
package com.yys534640040.d1_static;
public class User {
public static int onlineNumber;
// 实例化成员变量
public static String name;
public static int age;
public static void main(String[] args) {
//1.类名.静态成员变量
User.onlineNumber ++;
//同一个类中访问静态成员变量, 类名可以忽略不写
System.out.println(onlineNumber);
// 2.对象.实力成员变量
// System.out.println(name);
User u1 = new User();
u1.name = "猪八戒";
u1.age = 46;
System.out.println(u1.name);
System.out.println(u1.age );
u1.onlineNumber ++;
System.out.println(onlineNumber);
}
}
1．成员变量的分类和访问分别是什么样的?
静态成员变量（有static修饰，属于类、加载一次，可以被共享访问)，访问格式
类名.静态成员变量(推荐)
对象.静态成员变量(不推荐)。
实例成员变量（无static修饰，属于对象)，访问格式:
对象.实例成员变量。
2.两种成员变量各自在什么情况下定义?
·静态成员变量:表示在线人数等需要被共享的信息。
实例成员变量:属于每个对象，且每个对象信息不同时(name,age,...等)
static访问注意实现:
- 静态方法只能访问静态的成员，不可以直接访问实例成员。
- 实例方法可以访问静态的成员，也可以访问实例成员。
- 静态方法中是不可以出现this关键字的。
代码块概述
●代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。在Java类下，使用{}括起来的代码被称为代码块。
代码块分为
静态代码块:
格式: static{}
特点:需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景:在类加载的时候做一些静态数据初始化的操作，以便后续使用。
6.1 继承
什么是继承?
继承是类与类之间的一种关系。
●多个类继承单独的某个类，多个类就可使用单独的这个类的属性和行为了。多个类称为子类（派生类)，单独的这个类称为父类(基类或超类)。
为什么用继承?
●使用继承的好处:提高代码复用。
| people | Test |
|
|
|
| Students | Teacher |
|
|
1．什么是继承、继承的好处
继承是子类到父类的一种关系。
提高代码复用性，减少代码冗余，增强类的功能扩展性。
2．继承的格式
·子类extends父类
3.继承后子类的特点?
·子类继承父类，子类可以得到父类的属性和行为，子类可以使用。Java中子类更强大
在子类方法中访问成员（成员变量、成员方法）满足:就近原则
先子类局部范围找
●然后子类成员范围找
·然后父类成员范围找，如果父类范围还没有找到则报错。
如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办?
可以通过super关键字，指定访问父类的成员。
| 格式: super.父类成员变量/父类成员方法 |
override重写注解
- @Override是放在重写后的方法上，作为重写是否正确的校验注解。
- 加上该注解后如果重写错误，编译阶段会出现错误提示。
- 建议重写方法都加@Override注解，代码安全，优雅!
方法重写注意事项和要求
- 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
- 私有方法不能被重写。
- 子类重写父类方法时，访问权限必须大于或者等于父类（暂时了解∶缺省<protected < public)
- 子类不能重写父类的静态方法，如果重写会报错的。
|
|
|
this(...)和super(..)使用注意点:
子类通过this...）)去调用本类的其他构造器，本类其他构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器的。注意:this(...) super(..)都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。
|
|
什么是包?
包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
建包的语法格式: package 公司域名倒写.技术名称。报名建议全部英文小写，且具备意义
建包语句必须在第一行，一般IDEA工具会帮助创建
什么是权限修饰符?
- 权限修饰符:是用来控制一个成员能够被访问的范围的。
- 可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。
权限修饰符的分类和具体作用范围:
- 权限修饰符:有四种作用范围由小到大( private ->缺省-> protected - > public )
|
修饰符 |
同一个类中 |
同一个包中其他类 |
不同包下的子类 |
不同包下的无关类 |
|
private |
✔ |
|
|
|
|
缺省 |
✔ |
✔ |
|
|
|
protected |
✔ |
✔ |
✔ |
|
|
public |
✔ |
✔ |
✔ |
✔ |
常量
常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。
常量的作用和好处:可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。
package club.yys534640040.ATMapp.constans1;
public class cons {
public class Constant {
public static final String sCHOOL_NAME = "传智教育";
// 常量命名规范:英文单词全部大写，
public static final String LOGIN_NAME = "admin";
// 多个单词下划线连接起来。
public static final String PASS_WORD = "123456";
}
}
常量的执行原理
在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。
●这样做的好处是让使用常量的程序的执行性能与直接使用字面量是一样的。
选择常量做信息标志和分类:
- 代码可读性好，实现了软编码形式。
枚举的特征:
枚举类都是继承了枚举类型:java.lang.Enum枚举都是最终类，不可以被继承。
构造器的构造器都是私有的，枚举对外不能创建对象。枚举类的第一行默认都是罗列枚举对象的名称的。枚举类相当于是多例模式。
public enum orientation {
LEFT, UP, DOWN, RIGHT;
}
1、抽象类的作用是什么样的?什么时候定义抽象类?
可以被子类继承、充当模板的、同时也可以提高代码复用。
如果父类知道子类要完成某个功能，实现要交给子类时。
2、抽象方法是什么样的?
·只有方法签名，没有方法体，使用了abstract修饰。
3、继承抽象类有哪些要注意?
一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法。
否则这个类也必须定义成抽象类。
|
|
|
银卡同理,打印结果
当前账户:张三,总金额:1000.0,消费了:800.0,剩余余额:9200.0
9200.0
特征
- 有得有失:得到了抽象方法，失去了创建对象的能力。
- 抽象类为什么不能创建对象?
- 类有的成员（成员变量、方法、构造器）抽象类都具备
- 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
- 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
- 不能用abstract修饰变量、代码块、构造器。
final和abstract是什么关系?
- 互斥关系
- abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。
- 抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。
7.6 接口
接口的用法:
接口是用来被类实现（implements)的，实现接口的类称为实现类。实现类可以理解成所谓的子类。
|
修饰符class 实现类implements接口1,接口2,接口3，... { } |
|
|
|
|
基本小结
- 类和类的关系:单继承。
- 类和接口的关系:多实现。
- 接口和接口的关系:多继承，一个接口可以同时继承多个接口。
接口多继承的作用
- 规范合并，整合多个接口为同一个接口，便于子类实现。
什么是多态?
- 同类型的对象，执行同一个行为，会表现出不同的行为特征。
多态的常见形式
|
父类类型 对象名称=new子类构造器; 接口 对象名称=new实现类构造器; |
多态中成员访问特点
- 方法调用:编译看左边，运行看右边。
- 变量调用:编译看左边，运行也看左边。(多态侧重行为多态)
多态的前提
- 有继承/实现关系;有父类引用指向子类对象;有方法重写。
自动类型转换（从子到父):子类对象赋值给父类类型的变量指向。
强制类型转换吗（从父到子)
- 此时必须进行强制类型转换:子类对象变量=(子类)父类类型的变量
- 作用:可以解决多态下的劣势，可以实现调用子类独有的功能。
- 注意:如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException
| Animal t = new Tortoise(); Dog d = (Dog)t;//出现异常ClassCastException |
Java建议强转转换前使用instanceof判断当前对象的真实类型，再进行强制转换
| 变量名instanceof 真实类型 判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true反之。 |
|
|
|
|
1．引用数据类型的类型转换，有几种方式?
- 自动类型转换、强制类型转换。
2．强制类型转换能解决什么问题?强制类型转换需要注意什么。
可以转换成真正的子类类型，从而调用子类独有功能。
- 有继承关系/实现的2个类型就可以进行强制转换，编译无问题。
- 运行时，如果发现强制转换后的类型不是对象真实类型则报错。
- 类型转换异常:ClassCastException
Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化。
主要是用于在我们需要的时候创建一个对象来执行特定的任务，可以使代码更加简洁。
匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。
匿名类语法格式：
class outerClass {
// 定义一个匿名类
object1 = new Type(parameterList) {
// 匿名类代码
};
}
匿名类实现一个接口
以下实例创建的匿名类实现了 Polygon 接口：
interface Polygon {
public void display();
}
class AnonymousDemo {
public void createClass() {
// 匿名类实现一个接口
Polygon p1 = new Polygon() {
public void display() {
System.out.println("在匿名类内部。");
}
};
p1.display();
}
}
class Main {
public static void main(String[] args) {
AnonymousDemo an = new AnonymousDemo();
an.createClass();
}
}
开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。匿名内部类的代码可以实现代码进一步的简化（回扣主题)
1. Object的equals方法的作用是什么?
默认是与另一个对象比较地址是否一样
让子类重写，以便比较2个子类对象的内容是否相同
package club.yys534640040.Objects;
import java.util.Objects;
public class Test {
public static void main(String[] args) {
String s1 = null;
String s2 = new String("yys");
System.out.println(Objects.equals(s1, s2));
}
}
objects的equals方法比较的结果是一样的，但是更安全。
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
public class RunoobTest{
public static void main(String args[]){
StringBuilder sb = new StringBuilder(10);
sb.append("Runoob..");
System.out.println(sb);
sb.append("!");
System.out.println(sb);
sb.insert(8, "Java");
System.out.println(sb);
sb.delete(5,8);
System.out.println(sb);
}
}
9.1格式化时间（SimpleDateFormat）
java.text.SimpleDateFormat 以区域语言环境敏感的方式格式化和解析日期，可以将日期格式化为指定字符串和将字符串解析成日期。
java.text.SimpleDateFormat 可以根据用户定义的模式格式化日期
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main{
public static void main(String[] args){
Date date = new Date();
String strDateFormat = "yyyy-MM-dd HH:mm:ss";
SimpleDateFormat sdf = new SimpleDateFormat(strDateFormat);
System.out.println(sdf.format(date));
}
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
public static void main( String[] args ){
// 按指定模式在字符串查找
String line = "This order was placed for QT3000! OK?";
String pattern = "(\\D*)(\\d+)(.*)";
// 创建 Pattern 对象
Pattern r = Pattern.compile(pattern);
// 现在创建 matcher 对象
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
System.out.println("Found value: " + m.group(3) );
} else {
System.out.println("NO MATCH");
}
}
}
Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT Found value: 3000 Found value: ! OK?
本文作者： 永生
本文链接： https://yys.zone/detail/?id=229
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处！
发表评论
评论列表 (0 条评论)
暂无评论，快来抢沙发吧！