*
* 格式A>B?A:B ;
public class Demo01 {
public static void main(String[] args) {
int x=6;
boolean flag=false;
// if(x>1){
// flag=true;
// }else{
// flag=false;
// }
flag=x>1?true:false;
// int i=0;
// if(x>1){
// i=6;
// }else{
// i=1;
// }
int y=x>1?6:1;
System.out.println(flag);
System.out.println(y);
}
}
复习:
1、数据类型:基本数据类型,引用数据类型
2、八种基本数据类型:byte,short,int,long,float,double,char.boolean
引用数据类型:数组,class,String,接口
3、取值范围:byte -128~127(记住) short -2(15)~2(15)-1 int -2(31)~2(31)-1
4、算术运算符、 逻辑运算符、 比较运算符、 赋值运算符、 三元运算符
+,-,*,/,% && || ^ <,<=,>,>=,==,!= =,+=,-=,*=,/=,%= A>B?A:B
0%10=0
true&&false 结果:false
true||false 结果:true
true^false 结果:true
true^true 结果:false
3!=3 结果:false
5、语句结构:
if(boolean){}、if(boolean){}else{}、if(){}if else(){}else{}、switch(){} 判断等值条件
6、for{;;}循环,while(){}循环,do{} while();循环
for(Sysop("a");Sysop("b");Sysop("c")){
} //编译出错
int x=1;
for(Sysop("a");x<2;Sysop("c")){
x++;
} //结果为:ac
while(判断条件(boolean类型)){循环体} 先判断再执行循环体
do{循环体}while{判断条件(boolean类型)}; 先执行一次再循环
数组定义格式:
1.int [] arr1=new int[6]; //通常用于元素内容不确定情况下
2.int [] arr2=new int[]{2,1,3,6}; //通常用于元素内容确定情况下
3.int [] arr3={2,1,3,6}; //通常用于元素内容确定情况下
Sysop(arr1[0]);====》0
Sysop(arr1[6]);======》角标越界
String [] arr1=new int[6];
Sysop(arr1[0]);====》null
嵌套for循环
格式:
//外层循环控制轮数(行数)
for(){
//内层循环控制每轮的次数(每行的列数)
for(){
}
}
冒泡排序:数组里面相邻两个元素相比较
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1])
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1])=temp;
}
}
选择排序:数组里面先是第0个元素依次和其他元素比较,然后第1个元素依次和其他元素比较,以此类推。
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j])
int temp=arr[i];
arr[i]=arr[j];
arr[j])=temp;
}
}
直接排序调用方法:Array.sort(a) a为数组
增强for循环:
格式:for(元素类型 元素名称(随便起): 数组名称/集合名称){}
String [] strArr={"邓超","孙俪","黄晓明","杨颖"};
for(String s:strArr){
System.out.print(s+"\t");
}
输出结果为:
二维数组格式
//元素内容不确定
int[][] arr1=new int[3][6];//定义了一个名字叫arr1的二维数组,数组里面由3个一维数组,每一堆数组里面有6个整型的元素
Sysop(arr1[0][0]);==========》0
//当元素内容确定情况下
int[][] arr2={{1,2,3},{2,3,4},{4,3,2}};
for(int[] a:arr2){
for(int i:a){
System.out.print(i+" ");
}
}
输出结果为:
面向对象:简单来说,先通过关键字new实例化一个对象,然后调用对象里面的方法和属性
面向对象三大特征:封装、继承、多态
封装:常见两种表现形式:1.方法 2.private修饰符将所有属性都私有,然后对外提供公共的访问方法(get、set方法)。一个私有属性有两种赋值方式(1、set 2、构造),一种取值方式(get方法)
好处:提高代码的安全性,提高代码可维护性。
继承:什么时候用继承?is-a的关系(什么是什么的一种) 继承的好处:提高代码的复用性
Java支持单继承和多层继承 / 接口之间支持多继承(一个接口可以继承多个接口)和多层继承(接口A继承接口B,接口B继承接口C)
方法重写(复写、覆盖):前提是两个类是继承关系,子父类中两个方法,方法名一致,返回值类型一致,参数列表一致
方法重载:在同一个类当中,同名方法的参数列表不同即为重载,注意:与返回值类型无关。
抽象类和抽象方法:看不懂的方法(抽象方法),没有方法体的方法就是抽象方法。
抽象类里面的方法都是对所有子类的共性的行为的抽取,共性的变量不能定义为抽象的
抽象类和抽象方法得特点:1.抽象类和抽象方法必须被abstract关键字修饰
2.抽象类当中可以有非抽象方法,抽象类当中的方法也可以全是非抽象的
3.抽象方法所在的类必须是抽象类
4.抽象类可以有构造方法,当时抽象类不能实例化对象(编译错误)
5.抽象类当中的抽象方法必须被子类重写
面向接口编程:初期理解,一个抽象类里面假如全部都是抽象方法,那么这个抽象类就可以定义为一个接口
接口关键字:interface
接口特点:1.接口里面的方法都是抽象方法
2.一个类可以在继承一个抽象类的同时,实现一个或者多个接口
3.接口与接口之间可以存在多继承或者多层继承
4.当一个类实现多个接口的时候,多个接口里面不能存在这种情况:(方法名一样但返回值类型不一样)
5.接口中的变量都是常量,由固定的修饰符: public static final
6.一个类在实现多个接口的时候,那么多个接口中的常量命名尽量不要相同
什么是常量:1.被final修饰的变量就是常量。
2.只能被赋值一次,常量的值不能被修改,也不能被重新赋值
多态:一种事物可以有多种表现形式,比如说,猫可以叫猫,还可以叫宠物,还可以叫动物
多态的前提:必须存在继承或实现(接口)的关系
多态的体现方式:前提:class Pet(); //宠物类 class Cat(); //猫类
class Cat extends Pet();
1.Cat cat=new Cat();=====》Pet p=new Cat();
2.把多个重复的方法提取出来。用多态的方式,将多个重复的方法封装起来
public void show(Pet p){
p.eat();
p.method;
}
3.向上提升和向下转换
前提:class Pet() //宠物类 class Cat() //猫类
class Cat extends Pet();
//强制转换
Pet p=new Cat(); //强制转换的前提
Cat c=(Cat)p;
Cat c=new Cat();
Pet p=new Pet(); //向上提升
p=c;
多态的好处:提高代码复用性。
权限修饰符:public,pretected,private
public权限是最大的,本类能访问,同一个工程里面的所有包的类都能访问,子类也能访问
pretected权限,本类能访问,子类可以访问,同一个包里面的类也能访问,不通包里面的类不能访问
private权限:只能本类访问
static的用法:什么时候用静态?当我们操作共享数据的时候,那么这个共享数据就可以用static修饰
好处:节省了内存空间
特点:1.静态成员可以直接被类名调用,也可以被对象调用,简化了代码
2.静态只能访问静态
3.静态方法中不能出现this和super关键字
4.静态随着类的加载而加载,随着类的消失而消失,生命周期较长,在内存里面的时间较长,多了的话就比较消耗内存
静态代码块和构造代码块区别:
语法:静态代码块 static{} ,构造代码块{}
静态代码块:随着类的加载而加载,给类进行初始化的,程序一运行先加在静态代码块,然后再执行main方法(静态方法块优先于main方法执行),只能初始化一次
构造代码块:是给所有对象进行初始化,优先于构造方法执行,new几次调用几次
相应的构造方法,一般方法,构造代码块,静态代码块,main方法 的执行顺序
执行顺序:
1.静态代码块(只执行一次)>2.main方法>3.构造代码块>4.相应的构造方法>5.被调用的一般方法
final关键字:1.final修饰的变量叫常量
2.final修饰的类叫最终类,不能被继承
3.final修饰的方法叫最终方法,不能被重写
if(A instanceof B)
{ }
A是B的实例(对象)或者A是B的子类的实例(对象)
|
|