JAVA笔记-------基础篇

1.名词解释

软件：数据存储+数据展示+逻辑
内存：处理速度快，开机刷新清空。
硬盘：永久性存储，太慢。
CPU：运算  
B/S是浏览器和服务器，通过浏览器.
C/S是客服端和服务器，用过客户端进行交互

2.数据类型：

基本数据类型(值)：

整型：byte , short, int, long
浮点：float , double
布尔：boolean
字符：char

引用数据类型（地址）：

字符串String

变量： 数据类型 变量名 = 变量值；
常量:final, 只能初始化一次，

3.进制转换字符表示

0b --------表示二进制
0  --------八进制
0x --------十六进制

4.标识符

  1) 包括数字，字母，下划线_，$组成，但不能以数字开头
  2）不能是关键字
  3）见名知意，不要用中文和拼音

5.运算符：

1） 赋值运算符 =
2） 算术运算符 + - * / %; + 也起字符串的拼接
3） 比较运算符 > >= < <= == !=
4)  逻辑运算符  
            逻辑与:&& 两边都为真返回真，否则返回假
            逻辑或：|| 两边任意一个或两个为真返回真，两假返回假
            逻辑非：！ 为真返回假 假返回真
             逻辑异或：^  左右两边相同返回假，不同返回真
5) 位运算符：& ,| ^ ,<<, >>, >>> ,~
6) 三目运算符： **条件判断？表达式1：表达式2**   条件为真返回表达式1 否则返回表达式2

6.条件判断

选择语句—if
1)	单if语句，如果条件表达式为真，则执行语句块1，否则不执行
   
2)	if…else语句，如果条件表达式为真，则执行语句块1，否则执行语句块2
   
3)	if…else if…else语句，如果条件表达式为真，则执行语句块1，否则判断条件表达式2，如果为
    真则执行语句块2，否则判断条件表达式3…如果所有条件都不满足，则执行最后一个。
流程控制——switch
				语法格式：
				Switch(条件表达式){
				Case 表达式:            
				语句1；
				Break;
				Case 表达式:
				语句2；
				Break;
				 Case 表达式:
				语句n；
				Break;
				Default:
				语句n+1;
				Break；
				} 

Switch不可以跟long类型的数据

7.循环结构

循环结构——while
				While(条件表达式){
				     语句1；
				语句2；
				语句n;
				控制条件；
				}  
循环语句——do while
				 do{
				  语句1；
				  语句2；
			    	}while(条件)；
特点：循环体无论如何都会执行一次
循环语句——for
					 语法：for(初始化表达式;循环条件表达式;循环后的操作)
					{
					执行语句;
					}

注意：对于多层循环，continue关键字用于结束本次循环执行下一次循环，break关键字用于结束离它最近的一层循环，如果想要结束整个循环体，可以添加注释，可以指定结束那些循环。

8.数组

 用来存储多个相同数据类型的集合（容器）

定义：

1. 数据类型 [] 数组名 = { 数组值}；
2. 数据类型 [] 数组名 = new 数据类型 []{数组值}；
3. 数组类型 [] 数组名 = new 数据类型[数组长度];\ 定义完会后会有默认值:

Byte,short,int,long :0
Float,double:0.0
Char:/0
Boolean:false
String:null

注意：

1. 数组元素类型必须相同
2. 数组是什么数据类型？引用数据类型
3. 元素在内存中的空间是连续的
4. 数组是通过下标访问的 数组名[下标]
5. 数组的长度是通过length属性控制的，数组名.length
6. new 创建的数组空间是重新开辟的，与之前无关

增强for循环， foreach，循环次数由集合的元素个数决定
for(数据类型 i:数组名){
System.out.println(i);
}

for(String i:nameArr){
    	  System.out.println(i);
      }

9.数组常用方法

1. 旧数组复制到新数组----System.arraycopy(新数组，起始位置，旧数组，起始位置，复制长度)；
2. 横向打印----Arrays.toString(数组名);
3. 排序 ---- Arrays.sort(数组名);
4. 数组覆盖-----数据类型 [] 新数组名 = Arrays.copyOf(旧数组,旧数组长度)；
   -----------------int[] newArr = Arrays.copyOf(nameArr, nameArr.length);
5. 定向输出：-----数据类型 [] 新数组名 = Arrays.copyOfRange(旧数组,输出起始值包含它，输出结束值不包含它)
   ------------int [] newArr1 = Arrays.copyOfRange(nameArr, 1, 3);//[1,3)

10.二维数组

	数据类型 [] [] ={{数组值}；{数组值}；{数组值}；{数组值}}；

11.方法

方法的使用，方法调用机制（底层逻辑），学会画图
1.代码结构 2.重用性

访问修饰符 返回类型 方法名（参数列表）{ 方法体； }

注意：
1.方法不能定义在方法里面
2.返回类型——》输出， 参数——》输入
3.当没有返回类型的时候用void，如果有返回类型，则必须在方法体中通过return值返回回去
4.return会直接结束方法体，将值传递回去
5.方法的调用：方法名（参数值）;
6.参数列表：定义的时候是形参，调用的时候是实参
7.方法调用的时候，实参要跟形参一一对应（个数，类型，顺序）
8.方法的定义是没有顺序的
9.public static void main(String [] args)是特殊的方法，入口的功能
10.如果方法有返回类型，则方法中所有分支都必须有对应的返回值
11.方法的命名一般采用小驼峰命名规则 HelloWorld

可变参数：public static void sum(int …arr),一个方法只能定义一个可变参数且只能在其他非可变参数的最后面

12.面向对象—OOP

面向对象：OOP，注重的是谁来做
面向过程：注重怎么做

面向对象编程思想：分工与协作
在java中干活的是对象
什么是类？什么是对象？
成千上万个对象——>抽象出类
生活中先有类，后有对象
语法：数据类型 变量名 = new 构造方法();
包：在硬盘中的存在形式是目录
1.让代码文件管理更直观方便
2.命名冲突

我们使用其他类的时候需要导入这个类（包名+类名）
一般使用域名的倒序来命名包名
jdk定义好了很多类给我们使用，我们使用需要导包import
不能以java开头，java包名被jdk占用了
java.long.*包下的所有类都默认导入了
自己的包名用package来定义，它必须写在第一行（不考虑空行跟注释）

类中可以定义什么内容？
对象——抽象(特征，行为能力）——类
类(对象的模板)——孵化——对象(实例)
属性——成员变量:
方法：成员方法，构造方法

//属性：

            public String brand;
		    public String color;
		    public double price;  

构造方法：
1.不能有返回类型，如果定义了返回类型就是成员方法不是构造方法
2.如果没有定义构造方法，系统会默认一个无参构造方法
3.构造方法名必须与类名相同
4.构造方法可以定义多个，但是参数列表必须不一样
this：指当前对象
//行为能力：

		   public static void call(String  a) {
				System.out.println("打电话给"+a);
			}
           public static void palyGame() {
			 System.out.println("一起打王者");
		  }	

//创建对象及定义参数.
//数据类型 变量名 = new 构造方法();

       Phone p = new Phone();
       p.brand ="华为";
       p.color ="黑色";
       p.price =5000;

//属性的调用：对象.属性名

       System.out.println(p.brand);
       System.out.println(p.color);
       System.out.println(p.price);

//成员方法调用：对象.方法名();

       p.call("12123");
       p.palyGame();

13.封装

代码的不安全性:

其他程序可随意修改该类中的属性，封装的目的用于将对象的使用者和设计者分开，隐藏具体的实现细节，保护代码的安全性，通过封装，可以实现对属性的访问权限控制，同时增加了程序的可维护性

对象的封装：

使用private关键字：将属性私有化，这种属性只有本类访问，我们一般对每一个属性提供Public的get set这种方法提供外界访问我们的私有属性

通过创建对象去给对象属性赋值的三个方法：
1.直接赋值:

 p.price =5000;

2.构造器：

 public Phone(String brand, String color, double price) {
				this.brand = brand;
				this.color = color;
				this.price = price;
			}

3.get，set方法

public double getPrice() {
			return price;
		}
		public void setPrice(double price) {
			this.price = price;
		}

14.继承

继承：extends 直接拥有父类的属性跟方法(不包括构造方法)
1.java中只能有一个父类，单继承
2.继承过来的不满意可以重写
3.创建子类的对象必需要先创建父类的对象
4.this:表示当前对象，后面可以跟属性和方法
this(参数列表)：表示本类的构造方法，使用这种构造方法的时候必须写在第一行
super:表示调用父类方法
super(参数列表)：表示父类的构造方法

重写：继承过来的不满意可以重写

1.返回类型：基本数据类型必须一致
引用数据类型：父类的返回类型>=子类的返回类型
2.方法名必须相同
3.参数列表：必须一样
4.访问修饰符，异常

重载：对一种功能有多种实现方式
1.方法名一定要相同，
2.参数列表一定不能一样

final

一个类如果你没有定义它的父类，则默认继承Object final:修饰属性表示内容不能更改，而且必须初始化
fianl属性初始化：1.定义属性直接赋值，2.在构造器中初始化（为了抱在这个对象在创建完的时候这个final属性必须有初始值）

final:修饰方法表示这个方法不能被重写 final:修饰类表示这个类不能被继承

15.多态

多种表现形态
父类对象引用子类实例（需要父类对象的时候给子类实例）
方法：调用向左看，执行向右看

Person p = new Student();

属性：调用向左看，执行向左看
子类对象可以调用父类方法
但是父类对象不能调用子类方法

16.强制转换

子类转换成父类
有如下三个类 ，关系如下：
class Person{};
class Student extends Person{};
class BigStudent extends BigStudent{};

  person p = new Student();
  Student s = (Student)p;
  //父类强制转换成子类

Student s1 = new Student();
		  Person p1 = (Person)s1;
		  //子类强制转换成父类

Person p1 = new Student();
p.eat();a
//运行时错误  强制转换Student在线上，所以不能转，ClassCastException类转换异常

  Person obj = new BigStudent();
  String str = (String )obj;
 //Person 和 String 没有继承关系 所以编译异常

父类实例引用子类对象；但是子类实例不能引用父类对象

 public static void main(String[] args) {
		  method(new Person());//Person 类实例引用自身对象 可以
		  method(new Student());//Person（父类）实例引用Student（子类）对象 可以
		  method(new Object());  //Person（子类）实例引用Object（父类）对象 不可以

	}
	  
	  public static void method(Person p){  
	  }

用子类独有的方法？如何判断一个对象是什么类型？
instanceof:第一个操作数是表示对象，第二个操作数是类型，表达结果意义是这个对象是否是属于这个类型，结果是一个boolean类型

p instanceof  Student
//如果编译错误：没有继承关系
// false:该对象不属于这个类型，即不满足强转的条件
// 如果p可以强转成这个类型就返回true，不能就返回false

17.访问修饰符

4种访问修饰符可以修饰任意的属性或方法
外部类的修饰权限一般定义为public和default（内部类存在特殊情况），方法大多是public（设计模式或本类封装方法可能会采用Private和protected修饰），属性绝大多数都为private

18.抽象类—abstract

   1.只有方法的定义，没有方法的实现，让子类去实现
   2.抽象方法：被abstract关键字修饰的方法
   3.抽象不能有方法体，以；结束即可
   4.有抽象方法的类叫做抽象类，抽象类也是被abstract
   5.抽象类不能直接实例化，使用非抽象子类
   6.非抽象类不能有抽象方法
   7.抽象类可以没有抽象方法（抽象类中抽象方法的个数是0—N）

19.接口—interface

1. 当一个抽象类中所有的方法都是抽象的，那么我们就可以把它定义为一个接口，接口是对行为的抽象，类 是对属性和行为的抽象
2. 接口类的定义
   使用interface来定义接口
   语法：[public] interface 类名{ }
   子类实现接口采用implements关键字，java中支持多实现，它和extends有着同样的作用，类似于继承，但是这个叫实现，子类可以继承多个接口，接口可以用extends关键字继承接口，用逗号隔开
   语法：class 子类名 implements 父类名{ }
3. 接口中的方法 接口中的方法不需要abstract修饰，默认就是抽象的，会被隐式地指定为public abstract 方法且只能是public abstract方法，所以也不能够被实例化，也不能和static final private等关键字共存
4. 接口中的属性及书写规范
   接口中的变量会被隐式地指定为Public static final变量（并且只能是public static
   final 变量，用private修饰会编译报错）、
   接口中定义的属性：Public final static类型的，是一个常量
5. 使用接口的好处
   A．接口定义的是一种标准，可以使我们的代码分层开发，分模块开发
   B．降低代码的耦合度，提高代码的可拓展性和可维护性，代码编写过程中要遵循高聚合、低耦合
   C．接口改进了单继承的局限

1.抽象方法的个数0—n
2.接口是不能直接实例化的，必须使用实现类（implements）
3.类可以实现多个接口
4.接口是多继承
接口可以写的内容：
1.常量属性：默认加上 public final static
2.抽象方法：默认加上 public abstract
3.静态方法
4.default方法

20.静态变量—static

1.静态的内容是属于整个类所有，被所有的对象共有
2.静态（属性方法）：a.对象名.属性（方法） b.类名.属性（方法）
3.静态的内容是在类加载的时候初始化的
4.静态的不可以调用非静态的，而非静态的可以调用静态的

21.equals方法

euqals 用来比较指向的字符串对象所存储的字符串是否相等,不能用在基本上数据类型上面

22.比较器

1.内部比较器：Comparable
2.外部比较器：Comparator

23.包装类

24.集合 ArrayList

HashSet