文章目录
2020.7.8
栈内存和堆内存
栈内存:存储局部变量。使用完立消失。
堆内存:存储实体,对象。用完不会立消失,会在垃回收器空闲时回收。例子:
int [] a = new int[3];
//a存储于栈内存,new出来的对象存储于堆内存
//栈:局部变量使用完立消失,堆:实体,对象。用完不会立消失,会在垃回收器空闲时回收。
System.out.println(a);
//先找地址,再找到索引,进而找到索引对应的值
System.out.println(a[2]);
public class TestJava{
public static void main(String[] args){
int i[] ={10,20,30};
//静态初始化,i代表的是地址
System.out.println("修改前的值"+i[1]);
//传地址进去就是实参
exchange(i);
System.out.println("修改后的值"+i[1]);
//动态初始化
//new 为数组申请内存空间I@139a55
}
public static void exchange(int[] i){
i[1] = 80;
}
}
2020.7.9
super和this关键字的理解
this代表本类对象的引用(地址),super表示父类存储空间的标识。
this可以用来访问子类的成员变量、构造方法和子类成员方法,super可以用来访问父类的成员变量、构造方法和父类成员方法。
<p><tr>
<td>关键字</td>
<td>访问成员变量</td>
<td>访问构造方法</td>
<td>访问成员方法</td>
</tr>
<tr>
<td>this</td>
<td>this.成员变量</td>
<td>this(...)</td>
<td>this.成员方法</td>
</tr></p>
<p><tr>
<td>super</td>
<td>super.成员变量</td>
<td>super(...)</td>
<td>super.成员方法</td>
</tr></p>
继承中构造方法的访问特点:
子类创建对象的时候,子类构造方法第一句默认是super()
,也就是调用父类的无参构造方法。
package extend;
public class Fu {
public Fu(){
System.out.println("父类中的无参构造方法");
}
public Fu(int a){
System.out.println("父类中的带参构造方法");
}
}
package extend;
public class Zi extends Fu{
public Zi(){
//不写的话默认也是默认使用super
super(20);
System.out.println("子类中的无参构造方法");
}
public Zi(int a){
super(20);
System.out.println("子类中的带参构造方法");
}
}
package extend;
public class TestExtends {
public static void main(String[] args) {
// TODO Auto-generated method stub
Zi z1 = new Zi();
}
}
Override注解帮助检查方法重写声明的正确性
@Override
//Override注解帮助检查方法重写声明的正确性
public void show(){
//调用父类的show();
super.show();
System.out.println("子类中show()方法");
}
}
父类私有方法,子类无法重写。
子类方法的访问权限要不能比父类更低。(public > 默认 >private )
包
如果有相同名的类,使用包区分
带包编译命令如下:(注意.
)
javac -d . test.java
java源文件中加上包声明:
package com.lijugang.www;
public class test{
public static void main(String[] args){
System.out.println("hello world");
}
}
类
类是对象的抽象,对象是类的实体。
类有属性和行为,属性就是成员变量,行为就是成员方法。
成员变量存储于堆内存,系统会分配默认的初始值,而局部变量不会自动分配初始值,需要显示的初始化。
标准类的制作
1.成员变量(private修饰) 2.构造方法(无参和有参)3.set和get方法
封装
给成员变量加上private关键字,可以保护成员变量不被其他类直接使用,而在本类中可以直接使用。
如果要访问private修饰的成员变量,则需要通过get和set方法获取和设置值。
封装的好处?1.提高代码的安全性(private修饰成员变量,提供get和set方法),可以在方法中提供数据安全的校验。2.代码复用
2020.7.11
字符串
String s = “abc”,其实维护在常量池中,跟new出来的有区别
字符串比较内容通过equal()方法,比较值或者引用使用==。
StringBulider
是为了解决字符串拼接浪费时间和空间的问题。
append()返回对象本身。
public StringBuilder append(String str) {
super.append(str);
return this;
}
字符串翻转方法,直接匿名返回,链式编程(由于返回对象本身)。
public static String reverseString(String s){
return new StringBuilder(s).reverse().toString();
}
}
ArrayList
ArrayList存储学生对象,通过键盘录入
//students是个引用类型,方法里面改变,方法外面也会改变
//返回值:void
//参数:ArrayList
package com.lijugang.collection;
import java.util.ArrayList;
import java.util.Scanner;
public class StudentInput {
public static void main(String[] args) {
ArrayList<Student> students = new ArrayList<>();
while(true){
addStudent(students);
}
}
//students是个引用类型,方法里面改变,方法外面也会改变
//返回值:void
//参数:ArrayList<Student>
public static void addStudent(ArrayList<Student> students){
Scanner sc = new Scanner(System.in);
String name = sc.nextLine();
int age = sc.nextInt();
Student s = new Student(name,age);
students.add(s);
System.out.println(s.getAge()+s.getName());
}
}
final
修饰基本类型,基本类型就是常量,值不能改变。修饰引用的话,地址值不能改变。
static
1.被所用对象共享的成员变量使用static修饰,使用类名.变量名访问。
2.静态方法中只能访问静态成员变量和成员方法。
3.非静态的方法可以访问静态和非静态。
2020.7.12
多态
成员变量:编译看左边,执行看 左边。
成员方法:编译看左边,执行看右边。(由于重写)
多态的好处是在定义方法的时候,可以以父类对象作为参数,在使用的时候以子类型参与操作。弊端是不能使用子类的独有功能(可以使用向下转型解决这个问题,见下文)。
package duotai;
public class Animal {
public int weight = 10;
public int age = 20;
public void eat(){
System.out.println("动物吃东西");
}
}
package duotai;
public class Dog extends Animal {
public void eat(){
System.out.println("狗吃骨头");
}
//狗的独有方法
public void lookDoor(){
System.out.println("狗看门");
}
}
package duotai;
public class AnimalOperator {
public void useAnimal (Animal a){
a.eat();
}
}
package duotai;
public class Cat extends Animal {
public void eat(){
System.out.println("猫吃鱼");
}
public void playGame(){
System.out.println("猫在捉迷藏");
}
}
package duotai;
public class AnimalDemo {
public static void main(String[] args) {
AnimalOperator ao = new AnimalOperator();
Dog d = new Dog();
ao.useAnimal(d);
ao.lookDoor(d);//报错,lookDoor为独有方法
}
}
向下转型可以解决子类独有方法的访问问题,父类对象强转为子类对象。
package duotai02;
public class AnimalDemo {
public static void main(String[] args) {
//向上转型
Animal a = new Cat();
a.eat();
// Cat c = new Cat();
// c.playGame();
//向下转型,父类对象强转为子类对象
Cat c = (Cat)a;
c.playGame();
}
}
类型转换失败
package duotai02;
public class AnimalDemo {
public static void main(String[] args) {
//向上转型
Animal a = new Cat();//第一次分配内存空间,内存是猫
a.eat();
//向下转型
Cat c = (Cat)a;
c.playGame();
a = new Dog();//重新分配内存空间,内存是狗
Cat cc = (Cat)a;//狗不能转为猫
cc.eat();
}
}
Exception in thread "main" java.lang.ClassCastException: duotai02.Dog cannot be cast to duotai02.Cat at duotai02.AnimalDemo.main(AnimalDemo.java:15)
多态的形式:具体类的多态,抽象类的多态,接口类的多态
接口
1.接口中的成员变量默认是final和static修饰。
2.接口没有构造方法。
3.接口中不能有不能有非抽象方法,不能用public修饰,默认带abstract修饰。
public class Cat extends Object implements Jumpping{
//默认继承的是Object的构造方法
public Cat() {
}
public void jump(){
System.out.println("猫可以跳高了");
}
}
2020.8.1
引用类型的变量使用之前一般先判断是否为null,只要是对象,在使用之前就必须进行不为null的判断
Integer a = 100;
Integer a = null;//NullPointerException
if(a != null){
a += 300;
}
2020.8.2
runtime exception指程序运行期间出现的问题,编译时不检查,不需要捕获。例如数组越界。
可查异常,编译异常必须进行异常处理。
使用throws抛出异常,但没有做处理,不能向后执行。
throw用在方法体内部,使用形式为throw new 对象,throws是跟在类后面。
2020.8.9
Collection
常用方法
boolean add(E e),boolean remove(Object o),void clear,boolean contains(Object o),boolean isEmpty(),int size(),
遍历
Iterator iterator() ,有next()和hasNext()方法,这里会有并发修改异常,在listIterator()中解决
迭代器是依赖于集合而存在的,在判断成功之后,集合当中增加了新的元素,而迭代器却不知道,所以就报错了,这个就叫并发修改异常。
List
常用方法
void add(int index,E element), E remove(int index),E set(int index,E e),E get(int index)
遍历
listiterator() ----- 独有 void add(E e) 这个迭代器可以向列表中直接插入元素
注意返回值和 传的参数不一样,list的返回值类型为元素,Collection返回值类型为boolean。
ArrayList和Linkedlist
查找与插入、删除的区别。
Set
HashSet
要保证元素的唯一性,就必须重写hashcode()和equals()
hash table在jdk8之前,底层采用数组+链表实现,可以说是一个元素为链表的数组。在jdk8以后,在长度较长的时候做了优化。
首先对对象的哈希值模16(hashset默认初始容量为16),余数相同,则在这个位置上链式存储。按余数存储,比较哈希值和对象里面的内容。
LinkedHashSet
底层由链表和哈希表实现,保证不重复,有序。
public class LinkedHashSetTest {
public static void main(String[] args) {
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("asdaaaa");
linkedHashSet.add("sabbb");
linkedHashSet.add("vcccc");
linkedHashSet.add("vcccc");
for(String s:linkedHashSet){
System.out.println(s);
}
}
}
TreeSet
自然排序
无参构造方法使用自然排序对元素进行排序。就是让元素所属类实现Comparable接口,重写CompareTo()方法
重写方法时,一定要注意排序规则要按照要求的主要条件和次要条件来写
package collection0806;
import java.util.Objects;
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
//自然排序方法
public int compareTo(Student s) {
//返回0重复不排序
//正数升序
//this相当于s1,s相当于s2
int num = this.age - s.age;
int num2 = num==0?this.name.compareTo(s.name):num;
return num2;
}
}
public static void main(String[] args) {
TreeSet<Student> students = new TreeSet<>();
Student s1 = new Student("赵六",20);
Student s2 = new Student("张三",30);
Student s3 = new Student("王五",10);
Student s4 = new Student("测试",10);
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
for (Student s:students){
System.out.println(s.getAge()+s.getName());
}
}
比较器排序
带参构造方法:(接口的匿名类实现)
package treesettest;
public class Student {
private String name;
private int Chinese;
private int math;
public Student() {
}
public Student(String name, int chinese, int math) {
this.name = name;
Chinese = chinese;
this.math = math;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getChinese() {
return Chinese;
}
public void setChinese(int chinese) {
Chinese = chinese;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getSum(){
return this.getChinese()+this.getMath();
}
}
package treesettest;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeTestDemo {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
//int num = (s2.getChinese() + s2.getMath()) - (s1.getChinese() + s1.getMath());
int num = s2.getSum() - s1.getSum();//主要条件
int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;//次要条件
int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
return num3;
}
});
Student s1 = new Student("李好好", 80, 91);
Student s2 = new Student("李举刚", 90, 99);
Student s3 = new Student("王嘉婷", 100, 100);
Student s4 = new Student("张曼玉", 79, 92);//无次要条件,无法添加,重复元素
Student s5 = new Student("测试", 79, 92);//
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
for (Student s : ts) {
System.out.println(s.getName() + s.getSum());
}
}
}
内部类
成员内部类
和成员变量位置相同
public class OuterTest {
private int num =10;
private class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
OuterTest ot = new OuterTest();
ot.method();//间接调用了内部类
}
}
局部内部类
定义在类的方法里面
匿名内部类
new 类名或者接口名(){
//重写方法
}
new Inner(){
public voif show(){
}
}
本质:继承该类或者实现了该接口的子类匿名对象
2020.8.16
泛型类
定义格式:public class Generic{}
package fanxing0816;
public class Generic<T> {
private T t;
public Generic() {
}
public Generic(T t) {
this.t = t;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
package fanxing0816;
public class GenericDemo {
public static void main(String[] args) {
Generic<String> g1 = new Generic<String>();
g1.setT("sadad");
System.out.println(g1.getT());
Generic<Integer> g2 = new Generic<Integer>();
g2.setT(100);
System.out.println(g2.getT());
}
}
泛型方法
格式:public void show(T t){}
public class Generic{
public <T> void show(T t){
System.out.println(t);
}
}
泛型接口
格式:public interface Generic{}
package GenericImpl;
public interface Generic<T> {
void show(T t);
}
package GenericImpl;
public class GenericImpl<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
package GenericImpl;
public class GenericImplDemo {
public static void main(String[] args) {
GenericImpl<String> gt = new GenericImpl<String>();
gt.show("asdsadsa");
GenericImpl<Integer> gt2 = new GenericImpl<Integer>();
gt2.show(100);
}
}