Javase总结
数组和字符串
数组
-
类型[] 数组名 = new 类型 [数组长度]
int[] scores = new int[5];
int[] scores = new int[这里必须为空，不能指定长度]{78,91,84}; -
foreach 一种for特殊简化版，在遍历数组，集合时，更便捷
for(元素类型 元素变量(随便一个名字)：遍历对象){
执行的的代码；
}int[] scores = {1,2,3,4,5};
for(int score : scores){
System.out.println(score);
}
字符串
-
三种定义:
String s = “imooc”;
String s = new String();
String s = new String(“imooc”); -
String s1 = “imooc”;
String s2 = “imooc”；
s1 和 s2 相同的 ， 多次出现的字符常量，Java编译程序只创建一个，所以返回true。本质是s1先会再栈内存寻找“imooc”若无则把imooc创建到栈内存，s2也先是在栈内存寻找，找到了s1时创建的"imooc"则直接指向。所以说栈内存是数据共享的。 -
String s3 = new String(“imooc”);
String s4 = new String(“imooc”);
s3 和 s4 是不同的对象
使用System.out.println(“s1和s2内存地址相同吗？” + (s1 == s2));比较，相同返回true不相同返回false 。 == 在Java中比较的是地址
每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,
如果只需比较内容是否相同，应使用 ”equals()” 方法
本质上是只要new则会在堆内存开辟一个新的空间，则地址肯定是不相同的。 -
String类有很多方法 比如 int length();返回字符串的长度
-
讲基本类型转化为String类型
- 三种方法
1.包装类的toString()方法
2.使用String类的valueOf()
3.使用空字符串+基本类型
int c = 10;
String str1 = Integer.toString( c );
String str2 = String.valueOf( c );
String str3 = c + “”; -
将字符串类转换为基本类型
1.包装类的parseXxx静态方法
2.包装类的valueOf方法，转换为基本类型的包装类，会自动拆箱
String str = “4”;
int d = Integer.parseInt(str);
int e = Integer（注意类型）.valueOf(str); -
还有一个StringBulider类
-
public static void main(String[] args) {
// 创建一个空的StringBuilder对象 StringBuilder str = new StringBuilder(); // 追加字符串 str.append("jaewkjldfxmopzdm"); // 从后往前每隔三位插入逗号 for(int i = str.length();i>0;i-=3){ if(i != str.length()) str.insert(i,','); } // 将StringBuilder对象转换为String对象并输出 System.out.print(str.toString()); }
什么是类和对象
- 面向对象（oo）：就是你去买手机，说出你的需求，有手机的特征也有手机的行为。
- 面向过程(op）：只有主语手机 ， 和手机的特征。
- 对象：客观存在的事物，可以被描述，对象是类的实例，是类的具体的实现。
- 类：具有某一相同属性和行为的对象的集合，属性是对象所具有的，行为是对象可以干的，是方法。类是一种规范，是定义。
- 打个比方，类是一本土豆丝菜谱，而对象就是类的具体实现，是一盘土豆丝或者是一盒薯条等。
- 没有两个相同的对象，只要new就是不同的地址
对象内存图
- 单个对象：类中属性加载到堆内存。方法加载到栈内存。main中一旦实例化类，就在堆内存加载了类中的属性，成员变量都是初始值。之后执行方法，加载到堆内存，一个方法执行完毕之后在堆内存释放该方法资源，之后下一个。最后执行完main方法，释放main方法。
- 多个对象：再按照单个对象再次执行。只是对象的地址值不同。
- 栈内存：一些赋值操作,还不大理解
- 堆内存：new
成员变量和局部变量
- 成员变量：在类中定义，用来表示类中将有什么特征。可以作用与整个类和与本类有关联的其它类
- 局部变量：在方法中定义，不同方法可以有同名局部变量，但同一方法则不行。只能作用与此方法
- 成员变量会被赋予初始值，而局部变量则不行。成员变量String类型为null,int类型为0，布尔是false,浮点型是0.0,
- 成员变量和局部变量同名时，局部变量优先级更高
构造方法
- 构造方法语句格式
public 构造方法名(类名)（）{
//初始化代码
} - 构造方法一直会有存在，只要一new一个对象就相当于使用一次构造方法
- 构造方法名称和类名相同并没有返回值
- 系统会默认有一个无参的构造方法
this,static,final,import,super等关键字和instanceof
this
- this关键字代表当前对象
this.属性 操作当前对象的属性（类的属性）
this.方法 调用当前对象的方法（类中的方法） - 在封装时会使用，set和get方法。可自动生成 菜单栏里有
static
- 表示共享的意思，只要被赋值一次，则所有的访问值都一样
- 在类中定义成员变量 public static int a = 10;
- 则a可以通过 对象.a 访问 也可以通过 类名.a
- 访问特点：静态方法只可以访问静态成员，非静态方法都可以。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，通过对象来访问非静态变量
- main方法就是静态方法
final
- 使用final关键字做标识有最终的含义
- 可以修饰类，方法，属性和变量
当修饰类，则该类不允许被继承
当修饰方法，则该方法不允许被覆盖（重写）
final修饰属性, 则该类的属性不会进行隐式的（自动的）初始化（类被初始化属性必须有值）或在构造方法中赋值（但只能选其一）
final修饰变量，则该变量的值只能赋一次值，即变为常量
import
-可以通过import关键字，在某个文件中使用其它文件中的类,就是导包
super
- 在对象的内部使用，可以代表父类对象
- 子类的构造的过程当中必须调用其父类的构造方法
- 相当于在子类的构造方法中 隐式的写了super
- 如果想在子类写入super只能放在第一行
- 子类无参构造系统会自动加super()只是没显示出来，但是有参则必须手动添加super();
instanceof运算符
-
引用类型转换
1.向上类型转换（隐式/自动类型转换），是小到大
2.向下类型转换（强制类型转换），是大到小
-
instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题
会返回一个布尔值 用ifelse使用
instanceof ：用来判断内存中实际对象A是不是B类型，一般用来做类的类型判断。
访问修饰符
- 访问范围:private 只能在本类中使用
- 什么都不加(默认) 本类 同包
- protected 本类 同包 子类
- public 都可以
面向对象三大特征:封装，继承，多态
封装
-
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息
的操作和访问 -
添加private改变类的可见性为私有。增加getter/setter方法 用于属性的读写
-
get方法得到成员变量 ， set方法改变成员变量,可以一键生成
-
public int get(){
return a;
} -
public void set(int a){
this.a = a;
}
继承
-
继承就是子类继承父类的属性和方法。是单继承，子类只能继承一个父类，体现的关系是 is a
-
class 子类 extends 父类
-
继承访问特点
- 方法中使用一个变量，首先会自在方法中找，若无，则在成员变量中找，若无，则在父类中找
- 子类中所有构造方法都会默认访问父类的无参构造方法 -
重写， 就是在子类中写父类的同名方法（返回值类型，方法名，参数类型及个数都要一致），但是改变了方法内容。
-
好处：复用性提高，维护性提高。
-
坏处：父类发生变化子类不得不也发生变化，提高了耦合性，降低了子类的独立性
多态
- 一个事物在不同时刻不同对比下的 多种形态,比如动物 猫 狗 老鼠
- 多态前提和体现
- 有继承/实现关系
- 有方法的重写
- 有父类引用指向子类对象，就是Animal a = new Cat();此时，编译和运行a.成员变量 看的是Animal这个类中的的成员变量，a.方法编译看的是Animal，运行看的是Cat。
- 编译是看有没有，运行是看执行结果
- 好处:减少代码量，调用有很多子类通过传递子类对象调用父类共有方法时可以用父类的引用
public void eat(Animal a){
a.eat();
}
//调用时可以传递很多个子类对象来实现子类自己重写的方法
eat(new Cat());
eat(new Dog());
抽象类，接口，内部类
抽象类
- 必须使用abstract关键字进行修饰
- 可以有抽象方法，也可以有非抽象方法
- 抽象方法要使用需要被子类重写，才可以new
- 抽象类的子类 要么重写抽象方法，要么改子类为抽象类
- 抽象类中成员变量可以有初始值，也可以有构造方法，用来通过子类给父类初始化成员变量
接口
-
接口可以理解为一种特殊的类，由全局常量和公共抽象方法所组成
-
interface 接口名 ----定义接口
-
class 类名 extands 父类 implements 接口1，接口2 ----使用接口
-
接口中变量都是常量 ，默认被public static final修饰，即使不添加，系统也会自动添加
-
接口中方法都是抽象方法，public abstract 会自动添加
-
没有构造方法
-
类和接口 可以多实现，一个类实现多个接口
-
类和类 只可以单继承 但是可以多层
-
接口和接口，可以单继承也可以多继承
-
抽象类是对事物的抽象，接口是对行为的抽象
内部类
- 成员内部类：
- 使用为了拒绝别人直接访问某些代码，就是在类中在写一个类，内部类可以访问外部类的所有属性，包括private修饰的，外部类不能直接访问内部类
- 若是public修饰的内部类，外界可通过Outer.Inner in = new Outer().new Inter()就是 外部类名.内部类名 对象名 = 外部类对象.内部类对象 - 局部内部类:
- 该类在方法中使用，外界得通过在该方法中创建该类对象来使用，可直接访问外部类成员变量也可访问方法中的局部变量。 - 匿名内部类
- 本质是一个继承了该类或者实现了该接口的子类匿名对象
- 是局部内部类的一种形式，也得写在方法中
- 该类继承普通类或者抽象类 也可实现接口
- new 类名或者接口名（）{
重写方法；
}；
就是一个对象+方法的结合体
- 记住是个对象，则会有返回值(父类引用指向子类对象，多态)也可以调用方法，还是为了减少代码量。例如 有一个接口 public interface Jumpping{ void jump; } 有一个类，类中有一个方法 。 public class JumppingOperator{ public void method(Jumpping j){ j.jump(); } } 在一个测试类中，你想让猫可以跳高。 那么你得先创建一个猫类来继承父类。之后再重写接口的跳高方法， 创建对象，使用方法。再来一个狗，你又得重复创建类等等步骤。 有了匿名内部类，就不再需要创建很多类，直接创建一个匿名内部类， 有一个方法，参数是各个动物得对象， 你直接创建匿名对象，把方法重写的不一样就是不一样的对象。 JumppingOperator ji = new JumppingOperator(); ji.method(new Jumpping(){ public void Jump(){ System.out.println(“猫可以跳高”); } }) ji.method(new Jumpping(){ public void Jump(){ System.out.println(“狗可以跳高”); } })
2020/7/10 8:35 第一次写
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
