Core Java. Лекция 4

//его нельзя инстанцировать!
public interface Prism
{
   //это --- final-переменная!
   double PI = 3.14;

   //это --- публичные абстрактные методы!
   double getArea();
   double getHeight();

   //этот метод может вызывать другие и читать final-поля
   default double getVolume() {
      return getArea() * getHeight();
   }
}

public class Parallelepiped implements Prism {
    private double a;
    private double b;
    private double h;
    @Override
    public double getArea() {
        return a * b;
    }

    @Override
    public double getHeight() {
        return h;
    }
}

public enum Size
  { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

. . .

Size s = Size.MEDIUM;

for (Size s: Size.values()) . . .

switch (s) {
  case SMALL: . . .
  case LARGE: . . .
}

public enum Size
{
   SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");
   private final String abbreviation;
   private Size(String abbreviation) {
     this.abbreviation = abbreviation;
   }
   public String getAbbreviation() {
     return abbreviation;
   }
}

. . .

Size s = . . .
s.getAbbreviation(); // returns S, M, L or XL

interface Rule { boolean canGo();  }
enum TrafficLight implements Rule {
    RED {
        @Override public boolean canGo() { return false; }
        @Override int durationSeconds()  { return 55; }
    },
    YELLOW {
        @Override public boolean canGo() { return false; }
        @Override int durationSeconds()  { return 5; }
    },
    GREEN {
        @Override public boolean canGo() { return true; }
        @Override int durationSeconds()  { return 45; }
    };
    // Abstract method implemented individually by each constant
    abstract int durationSeconds();
}

//Defines a record with two int fields
public record Point(int x, int y) { }

public record Point(int x, int y) {
    public double distance(Point other) {
        int dx = x - other.x;
        int dy = y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
}

Point p1 = new Point(1, 2);
//Get value via implicit accessor method
System.out.println(p1.x());
System.out.println(p1.distance(new Point(3, 4)));

String a = "Java";
String b = new String("Java");
System.out.println(a == b); // false

var d1 = LocalDate.of(2026, 9, 29);
var d2 = d1.plusDays(1).minusDays(1);
System.out.println(d1 == d2); // true

C1 c1; C2 c2; C3 c3; I1 i1;

x instanceof A //  false, если x == null
c1 instanceof С2 // true или false
i1 instanceof C2 // true или false
c2 instanceof C1 // всегда возвращает true
с3 instanceof C2 // не скомпилируется

Person p = . . .;
if (p instanceof Student) {
    //если не защитить instanceof, возможен ClassCastException
    Student s = (Student) p;
    . . .
}

Person p = . . .;
if (p instanceof Student s) {
   //здесь доступна переменная Student s
    . . .
} else {
   //здесь недоступна переменная Student s
}

//Скомпилируется
if (obj instanceof String s && s.length() > 5) {
   . . .
   s.contains(..)
}

//НЕ скомпилируется
if (obj instanceof String s || s.length() > 5) {...}

public int calculate(Expr expr) {
  return switch (expr) {
    //Не скомпилируется, если мы забудем что-то из реализаций Expr!
    case Literal l -> l.value();
    case Divide d -> calculate(d.left()) / calculate(d.right());
    case Multiply m -> calculate(m.left()) * calculate(m.right());
    case Add a -> calculate(a.left()) + calculate(a.right());
    case Subtract s -> calculate(s.left()) - calculate(s.right());
  };
}

static String describe(Object o) {
  return switch (o) {
    case null -> "got null";

    case String s when s.isBlank() -> "blank string";
    case String s -> "string(" + s.length() + " chars)";
    case Integer i when i < 0 -> "negative int " + (-i);
    case Integer i            -> "int " + i;

    default -> "something else";
  };
}

sealed interface Animal permits Dog, Cat { String vocalize(); }

final class Dog implements Animal {
    @Override public String vocalize() { return "woof"; }
}
final class Cat implements Animal {
    @Override public String vocalize() { return "meow"; }
}

static String vocalize(Animal a) {
    return a.vocalize();
}

sealed interface Animal permits Dog, Cat { }
final class Dog implements Animal {}
final class Cat implements Animal {}

static String inEnglish(Animal a) {
    return switch (a) {
        case Dog d -> "dog";
        case Cat c -> "cat";
    }; }
static String inRussian(Animal a) {
    return switch (a) {
        case Dog d -> "собачка";
        case Cat c -> "кошечка";
    }; }

public class Person {
    private String name;
    private int age;
    @Override
    public boolean equals(Object o) {
       // никогда, НИКОГДА не пишите это сами
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class Person {
    private  int age;
    private  String name;
}

public class Person {
    private String name;
    private int age;
    . . .
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
. . .
Person person = . . .
System.out.println(person);

import lombok.ToString;

@ToString
public class Person {
    private  int age;
    private  String name;
}

public class Point {
  private final int x;
  private final int y;

  /*Подождите! Нам нужны:
   * конструктор
   * getX() и getY()
   * equals и hashCode
   * toString
   * 40 строчек кода из ничего!
   */

  public double distance(Point other) {
    ...
  }
}

import lombok.Data;

@Data
public class Point {
  private final int x;
  private final int y;
  public double distance(Point other) {
    ...
  }
}

record Point(int x, int y) {

}

public FileInputStream(String name) throws FileNotFoundException{
  . . .
}

class MyAnimation {
. . .
  public Image loadImage(String s)
    throws FileNotFoundException, EOFException {
    . . .
  }
}

throw new EOFException();

try {
  // . . . code . . .
  // . . . more code . . .
  // . . . more code . . .
} catch (ExceptionType e) {
  // handler for this type of exception
  // use e object to extract the data!
}

try {
  //code that might throw exceptions
} catch (FileNotFoundException e) {
  //emergency action for missing files
} catch (UnknownHostException e) {
  // emergency action for unknown hosts
} catch (IOException e) {
  // emergency action for all other I/O problems
}

try {
  //code that might throw exceptions
} catch (FileNotFoundException | UnknownHostException e) {
  //emergency action for missing files or unknown hosts

  //e type is the most specific common supertype
  //of the throwable types
}

. . . throws SQLException . . .

try {
  //доступ к БД -- может выбросить SQLException
} catch (Exception e) {
  logger.log(level, message, e);
  //хотя Exception есть тип более широкий,
  //чем задекларирован в методе, компилятор поймёт,
  //что всё ок
  throw e;
}

. . . throws ServletException . . .

try {
  //database access: SQLException can be thrown here
} catch (SQLException e) {
  ServletException se = new ServletException("database error");
  //we save information about the initial cause
  se.initCause(e);
  throw se;
}

try {
 ...
} catch (Exception e) {
 e.printStackTrace();
 //And compiler is happy!
 //(but your colleague who does the code review is not)
}

InputStream in = new FileInputStream(. . .);
try {
  // исключение может возникнуть здесь
  code that might throw exceptions
  // и даже возврат из метода вызовет блок finally!
  if (...)
    return;
} catch (IOException e) {
  // бывает, исключение возникает во время
  // обработки исключений
  show error message
} finally {
  // в любом случае сработает finally-блок!
  in.close();
}

...throws IOException...
//One resource

BufferedReader br = new BufferedReader(new FileReader(path));

try {return br.readLine();}

finally {br.close();}

...throws IOException...
//Two resources

InputStream in = new FileInputStream(src);
try {
  OutputStream out = new FileOutputStream(dst);
  try {
    byte[] buf = new byte[BUFFER_SIZE];
    int n;
    while ((n = in.read(buf)) >= 0)out.write(buf, 0, n);}
  finally {out.close();}}
finally {in.close();}

try (Resource res = . . .) {
  work with res
}

try (Scanner in = new Scanner(
    new FileInputStream("/usr/share/dict/words")), "UTF-8") {
  while (in.hasNext())
    System.out.println(in.next());
}

try (Scanner in = new Scanner(
     new FileInputStream("/usr/share/dict/words"), "UTF-8");
     PrintWriter out = new PrintWriter("out.txt")) {
  while (in.hasNext())
    out.println(in.next().toUpperCase());
}

//HORRIBLE. DON'T DO THIS
try {
  int i = 0;
  while (true)
    range[i++].climb();
} catch (ArrayIndexOutOfBoundsException e) {
}

//ДЕЛАЙТЕ ТАК!!
for (Mountain m: range)
  m.climb();

//HORRIBLE. DON'T DO THIS
try {
  Iterator<Foo> i = collection.iterator();
  while (true)
    Foo foo = i.next();
} catch (NoSuchElementException e) {
}

//DO THIS!!
for (Iterator<Foo> i = collection.iterator(); i.hasNext(); ) {
    Foo foo = i.next();
    . . .
}

//Bad: seed is calculated at each invocation. DON'T!!
double rnd = (new Random()).nextDouble();

//Before Java 7+ it was OK, but now DON'T!!
static final Random r = new Random();
static double random() {
  return r.nextDouble();
}

//Java 7-16: 3.6 times faster, statistically better
double rnd = ThreadLocalRandom.current().nextDouble();

//Java 17+: JEP356. Not thread safe!
RandomGenerator generator = RandomGenerator.getDefault();
generator.nextDouble();

String e = ""; // an empty string
String java = "Java\u2122"; //Java™

String greeting = "Hello!"
greeting = greeting.substring(0, 3) + "p!"; //Help!

String foo = "foo";
String bar = "bar";

System.out.println(foo + bar); //foobar

//Don't do this: the performance is poor!
String result = "";
for (int i = 0; i < numItems(); i++)
  result += lineForItem(i);
return result;

//You can allocate an approximate number of characters in advance
StringBuilder b = new StringBuilder(numItems() * LINE_WIDTH);
//And you can always use the default: new StringBuilder() (16 chars)
for (int i = 0; i < numItems(); i++)
  b.append(lineForItem(i));
return b.toString();

String greeting = "Hello";
int n = greeting.length(); // is 5.

int cpCount = greeting.codePointCount(0, greeting.length());

//works at O(1) time
char first = greeting.charAt(0); // first is 'H'
char last = greeting.charAt(4); // last is 'o'

int[] codePoints = str.codePoints().toArray();

int length()
boolean isEmpty() / boolean isBlank()
char charAt(int index)
int compareTo(String anotherString)
boolean equals(Object anObject)
boolean equalsIgnoreCase(String anotherString)
boolean startsWith(String prefix)
boolean endsWith(String suffix)
String toLowerCase() / String toUpperCase()
String trim()
String join(CharSequence delimiter, CharSequence... elements)