1.八大数据类型:
2.数据类型扩展
3.类型的转换
4.作用域
5.变量的命名规范
6.运算符
1.算数运算符
2.关系运算符
3.自增，自减，一元运算符
4.位运算
左移，右移 重点
左移 *2
右移 /2
效率非常高
5.三元运算符
字符串连接符
6.优先级
7.包的命名
8.JavaDoc
9.Scanner
next()和hasNext()
public class Demo02_Scanner {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收: ");
//判断用户有没有输入字符串
if (scanner.hasNext()){
//使用next方式接收
String str = scanner.next();//程序会等待输入内容，不输入会卡在这里
System.out.println("输出的内容为: "+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉
scanner.close();
}
}
nextLine()和hasNextLine()
public class Demo02_Scanner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收: ");
//判断是否还有输入
if (scanner.hasNextLine()) {
String str = scanner.nextLine();
System.out.println("输出的内容为: " + str);
}
scanner.close();
}
}
区别：
输入多个数字，并求其总和与平均数
import java.util.Scanner;
public class Demo_Scanner {
public static void main(String[] args) {
//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果:
Scanner scanner = new Scanner(System.in);
double sum = 0;
int m = 0;
//通过循环判断是否还有输入，并在里面对每-次进行求和和统计
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
m=m+1; //m++
sum=sum+x;
System.out.println("你输入了第"+m+"个数据，然后当前结果sum=" +sum) ;
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m +"个数的平均值是" + (sum / m));
scanner.close();
}
}
10.打印九九乘法表
11.break，continue
12.内存分析
栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
堆：存放用new产生的数据
静态域：存放在对象中用static定义的静态成员
常量池：存放常量
13.Arrays常用类
static <T> List<T> asList(T... a)
//将数组转换成集合
//eg：
List<Integer> list =Arrays.asList(1,2,3);
static int binarySearch(Object[] array, Object key)
//使用二分法查找数组内指定元素的索引值
static <T> T[] copyOf(T[] original, int newLength)
//拷贝数组，内部使用System.arraycopy() 方法，从下标0开始，如果超过原数组长度，会用null进行填充
static <T> T[] copyOfRange(T[] original, int from, int to)
//拷贝数组，指定起始位置和结束位置，如果超过原数组长度则会用null填充
static boolean equals(boolean[] a, boolean[] a2)
//判断两个数组是否相等，实际上比较的是两个数组的哈希值即Arrays.hashCode(data1) == Arrays.hashCode(data2)
static boolean deepEquals(Object[] a1, Object[] a2)
//判断两个多维数组是否相等，实际上比较的是两个数组的哈希值
static int hashCode(Object[] a)
//返回数组的哈希值
//eg：
Integer[] data = {1, 2, 3};
System.out.println(Arrays.hashCode(data)); // 30817
static void fill(Object[] a, int fromIndex, int toIndex, Object val)
//用指定元素田中数组，从fromIndex到toIndex，含头不含尾
static void sort(Object[] a)
//对数组元素进行排序
//eg：
String[] data = {"1", "4", "3", "2"};
Arrays.sort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]
static <T> void sort(T[] a, Comparator<? super T> c)
//使用自定义比较器，对数组元素进行排序（串行排序）
//eg：
String[] data = {"1", "4", "3", "2"};// 实现降序排序，返回-1放左边，1放右边，0保持不变
Arrays.sort(data, (str1, str2) -> {
if (str1.compareTo(str2) > 0) {
return -1;
} else {
return 1;
}
});
System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]
14.冒泡排序
//1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2. 每一次比较，都会产生出一个最大，或者最小的数字;
//3. 下一轮则可以少一次排序!
//4. 依次循环，直到结束!
public class test {
public static void main(String[] args) {
int[] a = {1, 4, 5, 6, 72, 2, 2, 2, 25, 6, 7};
int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array) {
//临时变量
int temp = 0;
//外层循环，判断我们这个要走多少次;
for (int i = 0; i < array.length - 1; i++) {
Boolean flag = false;
//内层循环，比价判断两个数，如果第一个数，比第二个数大,则交换位置
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] > array[j]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
15.稀疏数组
1.当一个数组中大部分元素为0,或者为同一-值的数组时，可以使用稀疏数组来保存该数组。
2.稀疏数组的处理方式是:
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
16.静态方法、非静态方法
静态方法
可以通过类直接调用，在类加载时加载，不能调用非静态方法
非静态方法
通过实例化对象调用
17.构造方法
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
必须和类的名字相同
必须没有返回类型,也不能写void
作用:
new本质在调用构造方法
初始化对象的值
注意点:
** 定义有参构造之后，必须定义无参构造器**
18.创建对象内存分析
19.三大特性：
封装
该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
封装(数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了：属性私有，get/set
好处
1.提高程序的安全性，保护数据.
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
继承
1.继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
2.extands的意思是“扩展”。子类是父类的扩展。
3.JAVA中类只有单继承，没有多继承!
4.被final修饰的类不能被继承。
5.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
1.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
2.子类和父类之间,从意义上讲应该具有"is a"的关系.
6.object类
java中的所有类都直接或间接继承Ob ject类
7.super
1.super注意点:
super调用 父类的构造方法，必须在构造方法的第一行
super 必须只能出现在子类的方法或者构造方法中!
super和 this 不能同时调用构造方法!
2.Vs this:
1.代表的对象不同:
this 本身调用者这个对象
super:代表父类对象的引用
2.前提
this:没有继承也可以使用
super:只能在继承条件才可以使用
3.构造方法
this() ; 本类的构造
super():父类的构造!
多态
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
- 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态，属性没有多态性。
注意点：
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系 类型转换异常! ClassCastException!
- 存在条件: 继承关系，方法需要重写，父类引用指向于类对象!
- 不能进行多态的方法：
- static 方法，属于类，它不属于实例
- final常量;
- private 方法;
instanceof关键字
(类型转换)引用类型， 判断一个对象是什么类型~
x instanceof y
instanceof是Java的一个保留关键字，左边是对象，右边是类，返回类型是Boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。
类型的转换：
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型；
- 把父类转换为子类，向下转型；强制转换
- 方便方法的调用，减少重复的代码!简介
- 封装、继承、多态! 抽象类，接口
static:
public class Student {
//2:赋初值~
{
System.out.println("匿名代码块");
}
//1 :只执行一次~
static {
System.out.println("静态代码块");
}
//3
public Student() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Student student = new Student();
System.out.println("==========");
Student student2 = new Student( );
}
}
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class demo01 {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
**抽象类：**抽象的抽象，约束~
- abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方;如果修饰类，那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
- 抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
- 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
- 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。
**接口：**只有规范
- 方法public abstract
- 常量public static final
- 接口不能被实例化，接口中没有构造方法
- implements 可以实现多个接口
- 必须要重写接口中的方法~
内部类：
-
内部类就是在一个类的内部在定义一个类,比如，A类中定义一个B类,那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
-
成员内部类
public class Outer { private int age = 10; public void out(){ System.out.println("这是外部类的方法"); } public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } public void getAge(){ System.out.println(age); } } }public class Applications { public static void main(String[] args) { //demo09 Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); inner.getAge(); inner.in(); outer.out(); } } -
静态内部类
-
局部内部类
//局部内部类 public void method(){ class Inner1{ public void in1(){ } } } -
匿名内部类
20.异常
- Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有是常的超类。
- 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。
- Error
- Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
- Java虚拟机运行错误(Virtual MachineError) ,当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机(JVM) 一般会选择线程终止;
- 还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError) 、链接错误(LinkageError)。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
- Exception
- 在Exception分支中有一个重要的子类RuntimeException (运行时异常)
◆ArrayIndexOutOfBoundsException (数组下标越界)
◆NullPointerException (空指针异常)
◆ArithmeticException (算术异常)
◆MissingResourceException (丢失资源)
◆ClassNotFoundException (找不到类)等异常, - 这些异常是不检查异常,程序中可以选择捕获处理，也可以不处理。
- 这些异常一般是由程序逻辑错误引起的， 程序应该从逻辑角度尽可能避免这类异常的发生;
- 在Exception分支中有一个重要的子类RuntimeException (运行时异常)
- Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的,当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程; Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
异常处理机制：
要捕获多个异常，要从小到大
685
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
