A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

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

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马