*
* 格式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的子类的实例（对象）

*
* 格式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的子类的实例（对象）