1.修饰符
1.属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. default是空的，与不加修饰符一样的作用。
作用范围最小原则：
简单说，能用private就用private，不行就放大一级，不行就用protected，最后用public。 这样就能把数据尽量的封装起来，不必要则不露出。
2.关键字
static
static:修饰变量、方法和代码块。
static修饰的成员变量称为静态变量或类变量。
static修饰的成员方法称为静态方法或类方法。
静态方法使用注意：
静态方法可以直接访问类变量和静态方法，不能访问普通成员变量或成员方法，但是普通成员方法可以直接访问类变量或成员方法。
静态方法中不能使用this、super关键字原因:
this代表对本类对象的引用，指向本类已经创建的对象；而super代表对父类对象的引用，指向父类对象；但是静态优先于对象存在。因为静态优先于对象存在，所以方法被静态修饰之后方法先存在，而方法里面要用到super指向的父类对象，但是所需的父类引用对象晚于该方法出现，也就是super所指向的对象没有，当然就会出错。
this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西。
静态代码块
定义在成员位置（类中方法外），使用static修饰的代码块。
public class Person {
public static int number;
static{
number=2;
}
}
随着类的加载而加载，且只加载一次，优先于main方法和构造方法的执行。
用来给类变量赋初值。
this
代表所在类的当前对象的引用（地址值），即对象自己的引用,谁调用就代表谁。
this和super都必须在构造方法的第一行，故不能同时出现。
super
父类的引用。
在 Java 程序中创建 Java 对象的时候会调用构造方法，在构造方法执行之前会先调用父类的构造方法，调用父类的构造方法实际上并不是创建父类对象，只是为了完成初始化当前子类对象的父类型特征。所以严格意义上来说 super 并不指向任何对象，super 只是代表了当前对象中的那部分父类型特征，单独输出 super，例如System.out.println(super);是无法编译的。
final
修饰类、方法和变量。
被修饰的类不能被继承。
被修饰的方法不能被重写。
被修饰的变量不能被重新赋值。
基本类型的局部变量：被final修饰后只能赋值一次，不能再次更改。
引用类型的局部变量：被final修饰后只能指向一个对象，地址不能再更改，但是不影响对象本身内部变量值的改变。
成员变量：初始化问题要么显示初始化，要么构造方法初始化。
final修饰常量名称一般所有字母都大写。
instanceof
3.数据类型
4.成员变量和局部变量的区别
类成员变量就是加static修饰的成员变量，也叫作静态变量。
独立于方法之外的变量，用static修饰，默认值与实例变量相似，一个类中只有一份，属于对象共有，存储在静态存储区，(方法区)，经常被声明为常量，调用一般是类名.静态变量名，也可以用对象名.静态变量名调用。
在Person类中，Person.age实现调用类成员变量age。
public class Person {
private String name;
static int age;
public void fangfa(){
int i=0;
System.out.println(i);
}
public static void main(String[] args) {
Person person=new Person();
person.fangfa();
String name = person.name;
int age = Person.age;
}
}
成员变量在类中，方法外，存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量在方法内或者代码块内（静态代码块等），也可以在方法上，例如形参，存在于栈内存中，随着所属区域的运行而存在，结束而释放。
5.构造方法和构造代码块
构造方法:当一个对象被创建时，构造方法用来初始化该对象，给对象的成员变量赋初始值。无论是否自定义构造方法，所有的类都有构造方法，因为JAVA自动提供一个无参构造方法，一旦自己定义了构造方法，默认提供的无参构造方法就失效。
格式:
public class Person {
private String name;
private int age;
//无参构造
public Person(){
}
//有参构造
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
构造代码块：构造代码块的出现就是为了提取构造函数的共同量,减少各个构造函数的代码而产生的。
对象一建立就运行，而且优先于构造函数运行。
构造代码块中定义的是不同对象共性的初始化内容。
作用： 给对象进行初始化。
构造代码块与构造函数的区别：
构造代码块是给所有对象进行统一初始化，构造函数是给对应的对象初始化。
细节： 构造代码块可以放在类中的任意位置。都会优先于构造函数执行，跟放置的位置无关。
6.方法的参数传递
7.面向对象–封装、继承、多态
8.常用类
String类
1. 内存分析
只要采用双引号赋值字符串，那么在编译期将会放到方法区中的字符串的常量池里,如果是运行时对字符串相加或相减会放到堆中（放之前会先验证方法区中是否含有相同的字符串常量，如果存在，把地址返回，如果不存在，先将字符串常量放到池中，然后再返回该对象的地址）
堆区中是运行期分配的，常量池中是编译器分配的
1.2 String常用方法
1.3StringBuffer和StringBuilder
日期类
java.util.Date
java.text.SimpleDateFormat
java.util.Calendar
public class date {
public static void main(String[] args) throws ParseException {
//生成当前时间
Date date = new Date();
System.out.println(date);
//格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1 = sdf.format(date);
System.out.println(date1);
Calendar c = Calendar.getInstance();//得到当前时间
System.out.println(c);
System.out.println(c.get(Calendar.DAY_OF_MONTH));
Date d = new SimpleDateFormat("yyyy-MM-dd").parse("2020-07-08");
c.setTime(d);
System.out.println(c.get(Calendar.DAY_OF_WEEK));
}
}
8.多线程
9.注解与反射
10.泛型
1.为什么用泛型？
对象实例化不指定泛型，默认为Object。
public class test {
public static void main(String[] args) {
List list=new ArrayList();
list.add("aaaa");
list.add("bbbbb");
list.add("cccc");
list.add(123);
list.add(true);
for (Object o : list) {
System.out.println(o);
}
}
}
虽然集合可以放各种对象，但一般只放同一种类型对象。否则取出时不能明确对象类型，容易发生ClassCastException异常。
在创建对象时，将未知的类型确定具体的类型。使用泛型可以将运行时期的ClassCastException异常转移到编译器编译失败，避免了类型转换的麻烦。
JAVA中的泛型只在编译期有效。
2.泛型类
public class test {
public static void main(String[] args) {
A<String> a = new A<String>();
a.setKey("hehe");
a.getKey();
}
//T代表未知的参数类型，未来传递什么什么就是什么类型。
static class A<T> {
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
}
3.泛型方法
调用方法时确定泛型的类型。
4.泛型接口
格式：修饰符 interface 接口名<代表泛型的变量>{}
有两种情况：1.未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加入到类中。2.实现接口时指定接口的泛型的具体类型，这个类实现接口所有方法的位置都要把泛型替换成实际的具体的数据类型。
5.泛型通配符
当使用泛型类或者接口时，传递的数据中泛型类型不确定，可以用通配符<?>表示。
<? extends 类>：只能接受该类型及其子类。
<? super 类>：只能接受该类型及其父类。
public class test {
public static void main(String[] args) {
Collection<Integer> list1=new ArrayList<Integer>();
Collection<String> list2=new ArrayList<String>();
Collection<Number> list3=new ArrayList<Number>();
Collection<Object> list4=new ArrayList<Object>();
getElement(list1);
//getElement(list2);
getElement(list3);
// getElement(list4);
// getElement2(list1);
// getElement2(list2);
getElement2(list3);
getElement2(list4);
}
private static void getElement(Collection<? extends Number> coll) {
}
private static void getElement2(Collection<? super Number> coll) {
}
}
11.集合
单列集合Collection:单列集合的根接口。
int size()：返回这个集合中的元素的数量。
boolean isEmpty()：返回集合是否包含元素，如果没有的话，返回true。
boolean contains(E e)：如果这个集合包含某个指定的元素，返回true。
Iterator<E> iterator()：返回这个集合中的所有元素的迭代。
boolean add(E e)：向集合中添加新的元素，如果添加成功，返回true。
boolean remove(E e)：从集合中删除指定元素，如果删除成功，返回true。
boolean containsAll(Collection<?> c)：这个集合是否包含指定集合中的所有的元素。
boolean addAll(Collection<? extends E> c)：添加指定的集合中的所有元素到这个集合中。
boolean removeAll(Collection<?> c)：删除当前集合中与给定集合相同的元素。在这个调用返回之后，这个集合将不包含和指定的集合一样的元素。
boolean retainAll(Collection<?> c)：从这个集合中删除所有不包含在指定的集合中的所有元素。
<T> T[] toArray(T[] a)：返回一个包含集合中所有的元素的数组。
void clear()：从集合中删除所有的元素。
boolean equals(Object obj)：比较这个集合和指定对象是否相等。
int hashCode()：返回这个集合的哈希值。
有两个子接口：
Set:元素无序、元素不可重复，实现类：
HashSet:
TreeSet:
List:元素有序、元素可重复。
void add(int index, Object element): 在指定位置index上添加元素element。
boolean addAll(int index, Collection c): 将集合c的所有元素添加到指定位置index。
Object get(int index): 返回List中指定位置的元素。
int indexOf(Object o): 返回第一个出现元素o的位置，否则返回-1。
int lastIndexOf(Object o) ：返回最后一个出现元素o的位置，否则返回-1。
Object remove(int index) ：删除指定位置上的元素。
Object set(int index, Object element) ：用元素element取代位置index上的元素，并且返回旧的元素。
实现类：
ArrayList:
ArrayList继承了AbstractList，实现了List接口，内部是一个数组，数据存储的结构是数组结构，元素增删慢，查找快。
LinkedList:是一个双向链表，提供首尾操作的方法，可作为堆栈、队列的结构使用。
双列集合Map:
HashMap:用哈希表（直接一点可以说数组加单链表）+红黑树实现的map类。
遍历：
1.keySet()方法，得到键的集合
Map<String,String> map=new HashMap<String,String>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value3");
Set<String> keys=map.keySet();
for(String key:keys){
system.out.println("key:"+key);
system.out.println("value:"+map.get(key));
}
2.entrySet方法返回Entry键值对对象
Map<String,String> map=new HashMap<String,String>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value3");
Set<Entry<String,String>> entryset=map.entrySet();
for (Entry<String,String> entry:entryset){
system.out.println("key:"+entry.getKey());
system.out.println("value:"+entry.getValue());
}
扫一扫
2422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
