javase1

javase基础语法
引用数据类型 ： Scanner类 ，Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，获取到录入的数据。
Scanner使用步骤：
导包：import java.util.Scanner;
创建对象实例：Scanner sc = new Scanner(System.in);
调用方法： int i = sc.nextInt(); 用来接收控制台录入的数字
String s = sc.next(); 用来接收控制台录入的字符串
代码实现

public class ScannerDemo01 {	
public static void main(String[] args) {	
	//创建Scanner引用类型的变量		
	Scanner sc = new Scanner(System.in);	
	//获取数字		
	System.out.println("请输入一个数字");		
	int n = sc.nextInt();		
	System.out.println("n的值为" + n);	
	//获取字符串		
	System.out.println("请输入一个字符串");	
	String str = sc.next();		
	System.out.println("str的值为" + str);	
		}
	}

随机数类，Random类
import导包：所属包java.util.Random
创建实例格式：Random 变量名 = new Random();

public class RandomDemo {	
public static void main(String[] args) {	
	// 创建Random类的实例		
	Random r = new Random(); 	
	// 得到0-100范围内的随机整数，将产生的随机整数赋值给i变量	
	int i = r.nextInt(100); 	
	//得到0.0-1.0范围内的随机小数，将产生的随机小数赋值给d变量		
	double d = r.nextDouble();
	System.out.println(i);
 	System.out.println(d); 
 	}
 	}	 		 			

三元运算符 ？
判断条件 ? 表达式1 : 表达式2

三元运算符会得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。

跳转语句 break continue
break 跳出循环
continue 跳出本次循环，可能还会有下一次

数组
定义数组 ： int[ ] x= new int [100] ; 定义长度为100的数组 x.length

方法的定义 ：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){ 执行语句
………
return 返回值;
}

代码

public static void main(String[] args){
int x=getArr(3,5);
System.out.println(x);
}
public static int getArr(int a,int b){
int java = a+b;
return  java;
} 

方法的重载：
代码：

public static void main(String[] args){
double x=getArr(3.5,5);
System.out.println(x);
}
public static int getArr(int a,int b){
int java = a+b;
return  java;
} 
public static double getArr(double a,int b){
double java  = a+b;
return java;

类：
1.1 引用数据类型分类提到引用数据类型（类）如使用过的Scanner类、Random类。我们可以把类的类型为两种：
第一种，Java为我们提供好的类，如Scanner类，Random类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。
类的定义格式：
创建java文件与类名一致。
public class 类名{
数据类型 文件名称；
数据类型 文件名称；
}

例如

public  class  phone {
String   bread;
String color;
double size ;
}

定义完类后，对类进行使用

public static Test{
	public static void main(String[] args){
	phone p = new phone();
	p.bread= "iphone11";
	p.color = "白色";
	p.size = "8";
		System.out.println("手机品牌"+ p.bread);
		System.out.println("手机颜色" + p.color);
		System.out.println("手机尺寸"+  p.size);
		}
}

ArrayList集合定义格式
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

import java.util.ArrayList;
public static void ArrayListDemo{
	public static void main(String[] args){
	ArrayList<String> list = new ArrayList<String>;
	list.add("DA1");
	list.add("DA2");
	list.add("DA3");
	list.add("DA4");
	System.out.println("集合的长度"+  list.size());
	//集合的遍历
	for(int i = 0;i<list.size() ; i++){
	System.out.println(list.get(i));
	}
	                        }
	                                             }

面向对象
创建对象类的方法 类名 对象名 = new 类名();
类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体

继承 格式
格式：class 子类 extends 父类 {}
成员变量： 如果子父类出现不同名的成员变量，这时访问没有问题，
如：

class Fu{
int num =5;
}


class Zi extends Fu{
int num2= 6;

	public void show(){
	System.out.println("fu"+ num);
	System.out.println("zi"+ num2);
	}
}


class Demo{
public static void main(String[] args){

	Zi z = new Zi();//创建子类对象
	z.shoW();//调用子类方法
	}
}

sp: 父类的成员是非私有的，子类可以直接访问，若父类的成员变量是私有的，子类不能直接访问。

当父子类出现同名时，子类访问父类的成员变量，必须使用关键字super。
super. 父类成员变量。
代码：

class Fu {
int num = 5;
}

class Zi extends Fu{
int num = 6;
	void show(){
	//子类出现相同成员变量时
	System.out.println("Fu " + super.num);
	System.out.println("Zi" + this.num);
	}
}

class Demo{
public static void main(String[] args){
Zi z= new Zi();
z.show();
}
}

子父类中出现一样的方法时，会出现覆盖操作，也称重写。
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。举例：比如手机，当描述一个手机时，它具有发短信，打电话，显示来电号码功能，后期由于手机需要在来电显示功能中增加显示姓名和头像，这时可以重新定义一个类描述智能手机，并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能，在其中增加显示姓名和头像功能

public class Test {	
public static void main(String[] args) {	
	new NewPhone().showNum();	
	}
}
	 //手机类
	 class Phone{	
	 public void sendMessage(){	
	 	System.out.println("发短信");
	 	}	
	 	public void call(){	
		System.out.println("打电话");	
		}
		public void showNum(){		
	 	System.out.println("来电显示号码");	
	 	}
	 	}

	 //智能手机类
	 	class NewPhone extends Phone{	
	 	//覆盖父类的来电显示号码功能，并增加自己的显示姓名和图片功能	
	 	public void showNum(){	
	 		//调用父类已经存在的功能使用super	
	 		super.showNum();	
	 		//增加自己特有显示姓名和图片功能
	 		System.out.println("显示来电姓名");	
	 		System.out.println("显示头像");	
	 		}
	 		}

抽象类：abstract
抽象方法
public abstract 返回值类型 方法名(参数);
抽象类
abstract class 类名 {}

1、抽象类一定是个父类？
是的，因为不断抽取而来的。
2、抽象类中是否可以不定义抽象方法。
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
3、抽象关键字abstract不可以和哪些关键字共存？
1、private：私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
2、final
3、static